import { GraphQLError } from 'graphql'
import * as jwt from 'jsonwebtoken'

import { prisma } from '../../../lib/prisma'
import { DaDataService } from '../../../services/dadata-service'
import { Context } from '../../context'
import { DomainResolvers } from '../shared/types'
// import { smsService } from '../../../lib/sms'  // TODO: импорт SMS сервиса

// Инициализация DaData сервиса
const dadataService = new DaDataService()

// Типы для JWT токена
interface AuthTokenPayload {
  userId: string
  phone: string
}

// JWT утилита
const generateToken = (payload: AuthTokenPayload): string => {
  return jwt.sign(payload, process.env.JWT_SECRET!, { expiresIn: '30d' })
}

// User Management Domain Resolvers - управление пользователями и профилем
export const userManagementResolvers: DomainResolvers = {
  Query: {
    // Получить текущего пользователя
    me: async (_: unknown, __: unknown, context: Context) => {
      console.warn('🔍 USER-MANAGEMENT ME QUERY:', { hasUser: !!context.user, userId: context.user?.id })
      
      if (!context.user) {
        console.warn('❌ USER-MANAGEMENT ME: No user in context')
        throw new GraphQLError('Требуется авторизация', {
          extensions: { code: 'UNAUTHENTICATED' },
        })
      }

      console.warn('🔍 USER-MANAGEMENT ME: Fetching user from DB...')
      const user = await prisma.user.findUnique({
        where: { id: context.user.id },
        include: {
          organization: {
            include: {
              apiKeys: true,
            },
          },
        },
      })
      
      console.warn('✅ USER-MANAGEMENT ME RESULT:', { 
        found: !!user, 
        hasOrganization: !!user?.organization,
        organizationType: user?.organization?.type,
        phone: user?.phone, 
      })
      
      return user
    },
  },

  Mutation: {
    // Отправка SMS кода для верификации
    sendSmsCode: async (_: unknown, args: { phone: string }) => {
      // TODO: Реализовать SMS сервис
      // const result = await smsService.sendSmsCode(args.phone)
      return {
        success: true,
        message: 'SMS код отправлен (заглушка)',
      }
    },

    // Проверка SMS кода
    verifySmsCode: async (_: unknown, args: { phone: string; code: string }) => {
      // TODO: Реализовать SMS верификацию
      // const verificationResult = await smsService.verifySmsCode(args.phone, args.code)

      // Заглушка для демо
      if (args.code !== '1234') {
        return {
          success: false,
          message: 'Неверный код (используйте 1234 для демо)',
          token: null,
          user: null,
        }
      }

      // Ищем существующего пользователя по номеру телефона
      let user = await prisma.user.findUnique({
        where: { phone: args.phone },
        include: {
          organization: {
            include: {
              apiKeys: true,
            },
          },
        },
      })

      // Если пользователь не найден, создаем нового
      if (!user) {
        user = await prisma.user.create({
          data: {
            phone: args.phone,
            // Остальные поля будут заполнены при регистрации
          },
          include: {
            organization: {
              include: {
                apiKeys: true,
              },
            },
          },
        })
      }

      // Создаем JWT токен
      const token = generateToken({
        userId: user.id,
        phone: user.phone,
      })

      return {
        success: true,
        message: 'Код верифицирован успешно',
        token,
        user,
      }
    },

    // Проверка ИНН через DaData API
    verifyInn: async (_: unknown, args: { inn: string }) => {
      console.log('🔍 VERIFY_INN STARTED:', { inn: args.inn })

      // Базовая проверка длины ИНН
      if (!args.inn || (args.inn.length !== 10 && args.inn.length !== 12)) {
        console.error('❌ VERIFY_INN: Некорректная длина ИНН:', args.inn)
        return {
          success: false,
          message: 'Некорректный ИНН. ИНН должен содержать 10 или 12 цифр',
          organization: null,
        }
      }

      try {
        // Валидация ИНН по контрольной сумме
        if (!dadataService.validateInn(args.inn)) {
          console.error('❌ VERIFY_INN: ИНН не прошел валидацию контрольной суммы:', args.inn)
          return {
            success: false,
            message: 'Некорректный ИНН. Проверьте правильность введенных цифр',
            organization: null,
          }
        }

        console.log('✅ VERIFY_INN: ИНН прошел валидацию, запрашиваем данные из DaData...')

        // Получение данных из DaData
        const organizationData = await dadataService.getOrganizationByInn(args.inn)

        if (!organizationData) {
          console.error('❌ VERIFY_INN: Организация не найдена в DaData:', args.inn)
          return {
            success: false,
            message: 'Организация с таким ИНН не найдена',
            organization: null,
          }
        }

        // Проверка статуса организации
        if (!organizationData.isActive) {
          console.warn('⚠️ VERIFY_INN: Организация неактивна:', {
            inn: args.inn,
            status: organizationData.status,
          })
          return {
            success: false,
            message: 'Организация не активна или ликвидирована',
            organization: null,
          }
        }

        console.log('✅ VERIFY_INN SUCCESS:', {
          inn: organizationData.inn,
          name: organizationData.name,
          isActive: organizationData.isActive,
        })

        return {
          success: true,
          message: 'ИНН верифицирован успешно',
          organization: {
            name: organizationData.name,
            fullName: organizationData.fullName,
            address: organizationData.address,
            isActive: organizationData.isActive,
          },
        }
      } catch (error) {
        console.error('💥 VERIFY_INN ERROR:', error)
        return {
          success: false,
          message: 'Ошибка при проверке ИНН. Попробуйте позже',
          organization: null,
        }
      }
    },

    // Добавление API ключа маркетплейса
    addMarketplaceApiKey: async (
      _: unknown,
      args: {
        input: {
          marketplace: 'WILDBERRIES' | 'OZON'
          apiKey: string
          warehouseId?: string
          supplierId?: string
          campaignId?: string
          clientId?: string
          clientSecret?: string
        }
      },
      context: Context,
    ) => {
      if (!context.user) {
        throw new GraphQLError('Требуется авторизация', {
          extensions: { code: 'UNAUTHENTICATED' },
        })
      }

      const currentUser = await prisma.user.findUnique({
        where: { id: context.user.id },
        include: { organization: true },
      })

      if (!currentUser?.organization) {
        throw new GraphQLError('У пользователя нет организации')
      }

      // Проверяем, что это селлер
      if (currentUser.organization.type !== 'SELLER') {
        throw new GraphQLError('API ключи доступны только для селлеров')
      }

      try {
        // TODO: Реализовать marketplace API keys когда модель будет готова
        // Заглушка для демо
        return {
          success: true,
          message: `API ключ ${args.input.marketplace} добавлен (заглушка)`,
          apiKey: {
            id: `api_key_${Date.now()}`,
            marketplace: args.input.marketplace,
            apiKey: args.input.apiKey,
            warehouseId: args.input.warehouseId,
            supplierId: args.input.supplierId,
            campaignId: args.input.campaignId,
            clientId: args.input.clientId,
            clientSecret: args.input.clientSecret,
            createdAt: new Date(),
            updatedAt: new Date(),
          },
        }
      } catch (error) {
        console.error('Error adding marketplace API key:', error)
        return {
          success: false,
          message: 'Ошибка при добавлении API ключа',
          apiKey: null,
        }
      }
    },

    // Удаление API ключа маркетплейса
    removeMarketplaceApiKey: async (_: unknown, args: { marketplace: 'WILDBERRIES' | 'OZON' }, context: Context) => {
      if (!context.user) {
        throw new GraphQLError('Требуется авторизация', {
          extensions: { code: 'UNAUTHENTICATED' },
        })
      }

      const currentUser = await prisma.user.findUnique({
        where: { id: context.user.id },
        include: { organization: true },
      })

      if (!currentUser?.organization) {
        throw new GraphQLError('У пользователя нет организации')
      }

      try {
        // TODO: Реализовать удаление API ключей когда модель будет готова
        return {
          success: true,
          message: `API ключ ${args.marketplace} удален (заглушка)`,
        }
      } catch (error) {
        console.error('Error removing marketplace API key:', error)
        return {
          success: false,
          message: 'Ошибка при удалении API ключа',
        }
      }
    },

    // Обновление профиля пользователя
    updateUserProfile: async (
      _: unknown,
      args: {
        input: {
          fullName?: string
          firstName?: string
          lastName?: string
          middleName?: string
          email?: string
          phone?: string
          avatarUrl?: string
          position?: string
          contactPerson?: string
          contactPhone?: string
          contactEmail?: string
        }
      },
      context: Context,
    ) => {
      if (!context.user) {
        throw new GraphQLError('Требуется авторизация', {
          extensions: { code: 'UNAUTHENTICATED' },
        })
      }

      try {
        // TODO: Проверка уникальности email когда поле будет в модели
        // if (args.input.email) {
        //   const existingUser = await prisma.user.findFirst({
        //     where: {
        //       email: args.input.email,
        //       NOT: { id: context.user.id },
        //     },
        //   })
        //
        //   if (existingUser) {
        //     return {
        //       success: false,
        //       message: 'Email уже используется другим пользователем',
        //       user: null,
        //     }
        //   }
        // }

        // Проверяем уникальность телефона, если он изменяется
        if (args.input.phone) {
          const existingUser = await prisma.user.findFirst({
            where: {
              phone: args.input.phone,
              NOT: { id: context.user.id },
            },
          })

          if (existingUser) {
            return {
              success: false,
              message: 'Телефон уже используется другим пользователем',
              user: null,
            }
          }
        }

        // Обновляем профиль пользователя (только доступные поля)
        const updatedUser = await prisma.user.update({
          where: { id: context.user.id },
          data: {
            // TODO: Добавить остальные поля когда они будут в модели
            ...(args.input.phone && { phone: args.input.phone }),
            updatedAt: new Date(),
          },
          include: {
            organization: {
              include: {
                apiKeys: true,
              },
            },
          },
        })

        return {
          success: true,
          message: 'Профиль обновлен успешно',
          user: updatedUser,
        }
      } catch (error) {
        console.error('Error updating user profile:', error)
        return {
          success: false,
          message: 'Ошибка при обновлении профиля',
          user: null,
        }
      }
    },
  },

  // Типовой резолвер для User
  User: {
    organization: async (parent: { organizationId?: string; organization?: unknown }) => {
      // Если организация уже загружена через include, возвращаем её
      if (parent.organization) {
        return parent.organization
      }

      // Иначе загружаем отдельно если есть organizationId
      if (parent.organizationId) {
        return await prisma.organization.findUnique({
          where: { id: parent.organizationId },
          include: {
            apiKeys: true,
            users: true,
          },
        })
      }

      return null
    },
  },
}