import { GraphQLError } from 'graphql'

import { prisma } from '../../../lib/prisma'
import { Context } from '../../context'
import { DomainResolvers } from '../shared/types'

// Supplies Domain Resolvers - управление поставками расходников и товаров
export const suppliesResolvers: DomainResolvers = {
  Query: {
    // Мои поставки (для селлеров и фулфилмента)
    mySupplies: async (_: unknown, __: unknown, 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('У пользователя нет организации')
      }

      const organizationId = currentUser.organization.id
      const organizationType = currentUser.organization.type

      console.warn('📦 MY_SUPPLIES RESOLVER CALLED:', {
        userId: context.user.id,
        organizationId,
        organizationType,
        timestamp: new Date().toISOString(),
      })

      let whereClause
      if (organizationType === 'WHOLESALE') {
        // Для поставщиков показываем их товары
        whereClause = { organizationId }
      } else if (organizationType === 'SELLER') {
        // Для селлеров показываем расходники
        whereClause = { organizationId }
      } else if (organizationType === 'FULFILLMENT') {
        // Для фулфилмента показываем V2 система расходников
        whereClause = {
          OR: [
            { organizationId }, // Наши расходники
            { fulfillmentCenterId: organizationId }, // Расходники партнеров на нашем складе
          ],
        }
      } else {
        whereClause = { organizationId }
      }

      const supplies = await prisma.supplyOrder.findMany({
        where: whereClause,
        include: {
          organization: {
            select: {
              id: true,
              name: true,
              fullName: true,
              type: true,
            },
          },
          fulfillmentCenter: {
            select: {
              id: true,
              name: true,
              fullName: true,
              type: true,
            },
          },
          logisticsPartner: {
            select: {
              id: true,
              name: true,
              fullName: true,
              type: true,
            },
          },
          items: {
            include: {
              product: {
                select: {
                  id: true,
                  name: true,
                  article: true,
                  type: true,
                },
              },
            },
          },
        },
        orderBy: { createdAt: 'desc' },
      })

      console.warn('📊 MY_SUPPLIES RESULT:', {
        suppliesCount: supplies.length,
        organizationType,
        statuses: supplies.map((s) => s.status),
      })

      return supplies
    },

    // Заказы поставок (для управления)
    supplyOrders: async (_: unknown, __: unknown, 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('У пользователя нет организации')
      }

      const organizationId = currentUser.organization.id
      const organizationType = currentUser.organization.type

      console.warn('📋 SUPPLY_ORDERS RESOLVER CALLED:', {
        organizationId,
        organizationType,
        timestamp: new Date().toISOString(),
      })

      // Определяем фильтр в зависимости от типа организации
      let whereClause
      if (organizationType === 'FULFILLMENT') {
        // Фулфилмент видит заказы поставок на свой склад
        whereClause = { fulfillmentCenterId: organizationId }
      } else if (organizationType === 'SELLER') {
        // Селлер видит свои заказы поставок
        whereClause = { organizationId }
      } else if (organizationType === 'WHOLESALE') {
        // Поставщик видит заказы своих товаров
        whereClause = { organizationId }
      } else {
        whereClause = { organizationId }
      }

      const supplyOrders = await prisma.supplyOrder.findMany({
        where: whereClause,
        include: {
          organization: {
            select: {
              id: true,
              name: true,
              fullName: true,
              type: true,
            },
          },
          fulfillmentCenter: {
            select: {
              id: true,
              name: true,
              fullName: true,
              type: true,
            },
          },
          logisticsPartner: {
            select: {
              id: true,
              name: true,
              fullName: true,
              type: true,
            },
          },
          items: {
            include: {
              product: {
                select: {
                  id: true,
                  name: true,
                  article: true,
                  type: true,
                },
              },
            },
          },
        },
        orderBy: { createdAt: 'desc' },
        take: 100, // Ограничиваем результаты
      })

      // Группируем для удобства
      const pendingSupplyOrders = supplyOrders.filter((order) => order.status === 'PENDING')
      const ourSupplyOrders = supplyOrders.filter((order) => order.organizationId === organizationId)
      const sellerSupplyOrders = supplyOrders.filter(
        (order) => order.organizationId !== organizationId && order.fulfillmentCenterId === organizationId,
      )

      console.warn('📊 SUPPLY_ORDERS RESULT:', {
        totalOrders: supplyOrders.length,
        pendingCount: pendingSupplyOrders.length,
        ourOrdersCount: ourSupplyOrders.length,
        sellerOrdersCount: sellerSupplyOrders.length,
      })

      return {
        supplyOrders: pendingSupplyOrders,
        ourSupplyOrders: ourSupplyOrders, // Расходники фулфилмента
        sellerSupplyOrders: sellerSupplyOrders, // Расходники селлеров
      }
    },

    // V1 Legacy: Поставщики поставок
    supplySuppliers: async (_: unknown, __: unknown, context: Context) => {
      console.warn('🏢 SUPPLY_SUPPLIERS (V1) - LEGACY RESOLVER')
      
      if (!context.user) {
        throw new GraphQLError('Требуется авторизация', {
          extensions: { code: 'UNAUTHENTICATED' },
        })
      }

      // TODO: Реализовать логику получения поставщиков поставок
      // Это V1 legacy резолвер - может потребоваться миграция на V2
      return []
    },
  },

  Mutation: {
    // ДУБЛИРОВАННЫЙ РЕЗОЛВЕР УДАЛЕН: createSupplyOrder
    // Этот резолвер перемещен в supply-orders.ts для соответствия GraphQL схеме

    // Обновить статус заказа поставки
    updateSupplyOrderStatus: async (
      _: unknown,
      args: {
        id: string
        status: string
        notes?: string
      },
      context: Context,
    ) => {
      console.warn('📝 UPDATE_SUPPLY_ORDER_STATUS - ВЫЗВАН:', {
        supplyOrderId: args.id,
        newStatus: args.status,
        timestamp: new Date().toISOString(),
      })

      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 {
        // Находим заказ поставки
        const supplyOrder = await prisma.supplyOrder.findFirst({
          where: {
            id: args.id,
            OR: [
              { organizationId: currentUser.organization.id }, // Создатель заказа
              { fulfillmentCenterId: currentUser.organization.id }, // Фулфилмент центр
              { logisticsPartnerId: currentUser.organization.id }, // Логистическая компания
            ],
          },
          include: {
            organization: true,
            fulfillmentCenter: true,
            logisticsPartner: true,
          },
        })

        if (!supplyOrder) {
          return {
            success: false,
            message: 'Заказ поставки не найден или нет доступа',
            supplyOrder: null,
          }
        }

        // Проверяем валидность перехода статуса
        const validTransitions: Record<string, string[]> = {
          PENDING: ['CONFIRMED', 'CANCELLED'],
          CONFIRMED: ['IN_TRANSIT', 'CANCELLED'],
          IN_TRANSIT: ['DELIVERED', 'CANCELLED'],
          DELIVERED: ['COMPLETED'],
        }

        if (!validTransitions[supplyOrder.status]?.includes(args.status)) {
          return {
            success: false,
            message: `Недопустимый переход статуса с ${supplyOrder.status} на ${args.status}`,
            supplyOrder: null,
          }
        }

        // Обновляем статус заказа
        const updatedSupplyOrder = await prisma.supplyOrder.update({
          where: { id: args.id },
          data: {
            status: args.status,
            notes: args.notes || supplyOrder.notes,
            updatedAt: new Date(),
          },
          include: {
            organization: true,
            fulfillmentCenter: true,
            logisticsPartner: true,
            items: {
              include: {
                product: true,
              },
            },
          },
        })

        console.warn('✅ СТАТУС ЗАКАЗА ПОСТАВКИ ОБНОВЛЕН:', {
          supplyOrderId: args.id,
          oldStatus: supplyOrder.status,
          newStatus: args.status,
          organizationType: currentUser.organization.type,
        })

        return {
          success: true,
          message: `Статус заказа изменен на ${args.status}`,
          supplyOrder: updatedSupplyOrder,
        }
      } catch (error) {
        console.error('Error updating supply order status:', error)
        return {
          success: false,
          message: 'Ошибка при обновлении статуса заказа',
          supplyOrder: null,
        }
      }
    },

    // Назначить логистику к заказу поставки
    assignLogisticsToSupply: async (
      _: unknown,
      args: {
        supplyOrderId: string
        logisticsPartnerId: string
        deliveryDate?: string
        notes?: string
      },
      context: Context,
    ) => {
      console.warn('🚚 ASSIGN_LOGISTICS_TO_SUPPLY - ВЫЗВАН:', {
        supplyOrderId: args.supplyOrderId,
        logisticsPartnerId: args.logisticsPartnerId,
        timestamp: new Date().toISOString(),
      })

      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 !== 'FULFILLMENT') {
        throw new GraphQLError('Только фулфилмент-центры могут назначать логистику')
      }

      try {
        // Проверяем заказ поставки
        const supplyOrder = await prisma.supplyOrder.findFirst({
          where: {
            id: args.supplyOrderId,
            fulfillmentCenterId: currentUser.organization.id,
            status: { in: ['PENDING', 'CONFIRMED'] },
          },
        })

        if (!supplyOrder) {
          return {
            success: false,
            message: 'Заказ поставки не найден или уже назначен',
            supplyOrder: null,
          }
        }

        // Проверяем логистическую компанию
        const logisticsPartner = await prisma.organization.findFirst({
          where: {
            id: args.logisticsPartnerId,
            type: 'LOGIST',
          },
        })

        if (!logisticsPartner) {
          return {
            success: false,
            message: 'Логистическая компания не найдена',
            supplyOrder: null,
          }
        }

        // Назначаем логистику
        const updatedSupplyOrder = await prisma.supplyOrder.update({
          where: { id: args.supplyOrderId },
          data: {
            logisticsPartnerId: args.logisticsPartnerId,
            deliveryDate: args.deliveryDate ? new Date(args.deliveryDate) : supplyOrder.deliveryDate,
            status: 'CONFIRMED',
            notes: args.notes || supplyOrder.notes,
            updatedAt: new Date(),
          },
          include: {
            organization: true,
            fulfillmentCenter: true,
            logisticsPartner: true,
            items: {
              include: {
                product: true,
              },
            },
          },
        })

        console.warn('✅ ЛОГИСТИКА НАЗНАЧЕНА НА ЗАКАЗ:', {
          supplyOrderId: args.supplyOrderId,
          logisticsPartnerId: args.logisticsPartnerId,
          logisticsPartnerName: logisticsPartner.name || logisticsPartner.fullName,
          deliveryDate: args.deliveryDate,
        })

        return {
          success: true,
          message: 'Логистика успешно назначена на заказ',
          supplyOrder: updatedSupplyOrder,
        }
      } catch (error) {
        console.error('Error assigning logistics to supply:', error)
        return {
          success: false,
          message: 'Ошибка при назначении логистики',
          supplyOrder: null,
        }
      }
    },

    // Удалить заказ поставки (только до отгрузки)
    deleteSupplyOrder: async (_: unknown, args: { id: string }, context: Context) => {
      console.warn('🗑️ DELETE_SUPPLY_ORDER - ВЫЗВАН:', {
        supplyOrderId: args.id,
        timestamp: new Date().toISOString(),
      })

      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 {
        // Находим заказ поставки
        const supplyOrder = await prisma.supplyOrder.findFirst({
          where: {
            id: args.id,
            organizationId: currentUser.organization.id, // Только создатель может удалить
            status: { in: ['PENDING', 'CANCELLED'] }, // Можно удалить только ожидающие или отмененные
          },
        })

        if (!supplyOrder) {
          return {
            success: false,
            message: 'Заказ поставки не найден или не может быть удален',
          }
        }

        // Удаляем заказ и связанные позиции (каскадно через Prisma)
        await prisma.supplyOrder.delete({
          where: { id: args.id },
        })

        console.warn('🗑️ ЗАКАЗ ПОСТАВКИ УДАЛЕН:', {
          supplyOrderId: args.id,
          organizationId: currentUser.organization.id,
          status: supplyOrder.status,
        })

        return {
          success: true,
          message: 'Заказ поставки успешно удален',
        }
      } catch (error) {
        console.error('Error deleting supply order:', error)
        return {
          success: false,
          message: 'Ошибка при удалении заказа поставки',
        }
      }
    },

    // Массовое обновление статусов заказов
    bulkUpdateSupplyOrders: async (
      _: unknown,
      args: {
        ids: string[]
        status: string
        notes?: string
      },
      context: Context,
    ) => {
      console.warn('📝 BULK_UPDATE_SUPPLY_ORDERS - ВЫЗВАН:', {
        orderIds: args.ids,
        newStatus: args.status,
        count: args.ids.length,
        timestamp: new Date().toISOString(),
      })

      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 {
        // Обновляем статусы всех указанных заказов
        const result = await prisma.supplyOrder.updateMany({
          where: {
            id: { in: args.ids },
            OR: [
              { organizationId: currentUser.organization.id }, // Создатель заказа
              { fulfillmentCenterId: currentUser.organization.id }, // Фулфилмент центр
              { logisticsPartnerId: currentUser.organization.id }, // Логистическая компания
            ],
          },
          data: {
            status: args.status,
            notes: args.notes,
            updatedAt: new Date(),
          },
        })

        console.warn('✅ МАССОВОЕ ОБНОВЛЕНИЕ СТАТУСОВ:', {
          requestedCount: args.ids.length,
          updatedCount: result.count,
          newStatus: args.status,
          organizationType: currentUser.organization.type,
        })

        return {
          success: true,
          message: `Обновлено ${result.count} заказов из ${args.ids.length}`,
          updatedCount: result.count,
        }
      } catch (error) {
        console.error('Error bulk updating supply orders:', error)
        return {
          success: false,
          message: 'Ошибка при массовом обновлении заказов',
          updatedCount: 0,
        }
      }
    },

    // V1 Legacy: Обновить цену поставки
    updateSupplyPrice: async (
      _: unknown,
      args: {
        supplyId: string
        price: number
        priceType?: string
      },
      context: Context,
    ) => {
      console.warn('💰 UPDATE_SUPPLY_PRICE (V1) - LEGACY RESOLVER:', {
        supplyId: args.supplyId,
        price: args.price,
        priceType: args.priceType,
      })

      if (!context.user) {
        throw new GraphQLError('Требуется авторизация', {
          extensions: { code: 'UNAUTHENTICATED' },
        })
      }

      // TODO: Реализовать V1 логику обновления цены поставки
      // Может потребоваться миграция на V2 систему ценообразования
      return {
        success: false,
        message: 'V1 Legacy - требуется реализация',
      }
    },

    // V1 Legacy: Создать поставщика поставки
    createSupplySupplier: async (
      _: unknown,
      args: {
        input: {
          organizationId: string
          supplyId: string
          terms?: string
          contactInfo?: string
        }
      },
      context: Context,
    ) => {
      console.warn('🏭 CREATE_SUPPLY_SUPPLIER (V1) - LEGACY RESOLVER:', args.input)

      if (!context.user) {
        throw new GraphQLError('Требуется авторизация', {
          extensions: { code: 'UNAUTHENTICATED' },
        })
      }

      // TODO: Реализовать V1 логику создания поставщика поставки
      // Может потребоваться миграция на V2 систему управления поставщиками
      return {
        success: false,
        message: 'V1 Legacy - требуется реализация',
        supplier: null,
      }
    },

    // V1 Legacy: Обновить параметры поставки
    updateSupplyParameters: async (
      _: unknown,
      args: {
        supplyId: string
        parameters: Record<string, any>
      },
      context: Context,
    ) => {
      console.warn('⚙️ UPDATE_SUPPLY_PARAMETERS (V1) - LEGACY RESOLVER:', {
        supplyId: args.supplyId,
        parametersKeys: Object.keys(args.parameters || {}),
      })

      if (!context.user) {
        throw new GraphQLError('Требуется авторизация', {
          extensions: { code: 'UNAUTHENTICATED' },
        })
      }

      // TODO: Реализовать V1 логику обновления параметров поставки
      // Может потребоваться миграция на V2 систему конфигурации
      return {
        success: false,
        message: 'V1 Legacy - требуется реализация',
        supply: null,
      }
    },
  },
}