import { prisma } from '../../../lib/prisma'
import { MarketplaceService, MarketplaceValidationResult } from '../../../services/marketplace-service'

// Типы для API ключей
export interface ApiKeyInput {
  marketplace: 'WILDBERRIES' | 'OZON'
  apiKey: string
  clientId?: string // для Ozon
}

export interface ApiKeyCreationResult {
  success: boolean
  message: string
  apiKey?: {
    id: string
    marketplace: string
    isActive: boolean
    validationData: object | null
  }
}

// Shared utility для работы с API ключами в модульной архитектуре
export class ApiKeyUtility {
  private marketplaceService: MarketplaceService

  constructor() {
    this.marketplaceService = new MarketplaceService()
  }

  /**
   * Валидирует API ключ перед сохранением
   */
  async validateApiKey(apiKeyInput: ApiKeyInput): Promise<MarketplaceValidationResult> {
    const { marketplace, apiKey, clientId } = apiKeyInput

    // Проверяем формат ключа
    if (!this.marketplaceService.validateApiKeyFormat(marketplace, apiKey)) {
      return {
        isValid: false,
        message: `Неверный формат API ключа для ${marketplace}`,
      }
    }

    // Валидируем ключ через API маркетплейса
    return await this.marketplaceService.validateApiKey(marketplace, apiKey, clientId)
  }

  /**
   * Создает API ключ в базе данных после валидации
   */
  async createApiKey(
    organizationId: string,
    apiKeyInput: ApiKeyInput,
  ): Promise<ApiKeyCreationResult> {
    try {
      console.warn('🔑 API_KEY_CREATION - НАЧАЛО:', {
        organizationId,
        marketplace: apiKeyInput.marketplace,
        hasApiKey: !!apiKeyInput.apiKey,
        hasClientId: !!apiKeyInput.clientId,
        timestamp: new Date().toISOString(),
      })

      // Валидируем API ключ
      const validationResult = await this.validateApiKey(apiKeyInput)

      if (!validationResult.isValid) {
        console.warn('❌ API ключ не прошел валидацию:', validationResult.message)
        return {
          success: false,
          message: validationResult.message,
        }
      }

      console.warn('✅ API ключ прошел валидацию:', {
        marketplace: apiKeyInput.marketplace,
        sellerId: validationResult.data?.sellerId,
        sellerName: validationResult.data?.sellerName,
      })

      // Проверяем, нет ли уже API ключа для этого маркетплейса
      const existingApiKey = await prisma.apiKey.findFirst({
        where: {
          organizationId,
          marketplace: apiKeyInput.marketplace,
        },
      })

      if (existingApiKey) {
        console.warn('⚠️ API ключ для этого маркетплейса уже существует, обновляем')
        
        // Обновляем существующий ключ
        const updatedApiKey = await prisma.apiKey.update({
          where: { id: existingApiKey.id },
          data: {
            apiKey: apiKeyInput.apiKey,
            clientId: apiKeyInput.clientId || null,
            isActive: true,
            validationData: validationResult.data ? JSON.stringify(validationResult.data) : null,
            updatedAt: new Date(),
          },
        })

        console.warn('🔄 API ключ обновлен:', {
          apiKeyId: updatedApiKey.id,
          marketplace: updatedApiKey.marketplace,
          isActive: updatedApiKey.isActive,
        })

        return {
          success: true,
          message: `API ключ ${apiKeyInput.marketplace} успешно обновлен`,
          apiKey: {
            id: updatedApiKey.id,
            marketplace: updatedApiKey.marketplace,
            isActive: updatedApiKey.isActive,
            validationData: updatedApiKey.validationData 
              ? JSON.parse(updatedApiKey.validationData as string) 
              : null,
          },
        }
      }

      // Создаем новый API ключ
      const newApiKey = await prisma.apiKey.create({
        data: {
          organizationId,
          marketplace: apiKeyInput.marketplace,
          apiKey: apiKeyInput.apiKey,
          clientId: apiKeyInput.clientId || null,
          isActive: true,
          validationData: validationResult.data ? JSON.stringify(validationResult.data) : null,
        },
      })

      console.warn('✅ API ключ создан:', {
        apiKeyId: newApiKey.id,
        organizationId: newApiKey.organizationId,
        marketplace: newApiKey.marketplace,
        isActive: newApiKey.isActive,
      })

      return {
        success: true,
        message: `API ключ ${apiKeyInput.marketplace} успешно добавлен`,
        apiKey: {
          id: newApiKey.id,
          marketplace: newApiKey.marketplace,
          isActive: newApiKey.isActive,
          validationData: newApiKey.validationData 
            ? JSON.parse(newApiKey.validationData as string) 
            : null,
        },
      }
    } catch (error) {
      console.error('🔴 Ошибка создания API ключа:', error)
      return {
        success: false,
        message: 'Ошибка при сохранении API ключа',
      }
    }
  }

  /**
   * Создает несколько API ключей для организации
   */
  async createMultipleApiKeys(
    organizationId: string,
    apiKeys: ApiKeyInput[],
  ): Promise<{ success: boolean; results: ApiKeyCreationResult[]; sellerData?: any }> {
    const results: ApiKeyCreationResult[] = []
    let primarySellerData: any = null

    console.warn('🔑 СОЗДАНИЕ МНОЖЕСТВЕННЫХ API КЛЮЧЕЙ:', {
      organizationId,
      count: apiKeys.length,
      marketplaces: apiKeys.map(k => k.marketplace),
    })

    for (const apiKeyInput of apiKeys) {
      const result = await this.createApiKey(organizationId, apiKeyInput)
      results.push(result)

      // Сохраняем данные продавца из первого успешно проверенного ключа
      if (result.success && result.apiKey?.validationData && !primarySellerData) {
        primarySellerData = result.apiKey.validationData
        console.warn('🏪 ДАННЫЕ ПРОДАВЦА ПОЛУЧЕНЫ:', {
          marketplace: apiKeyInput.marketplace,
          sellerName: primarySellerData.sellerName,
          sellerId: primarySellerData.sellerId,
        })
      }
    }

    const successCount = results.filter(r => r.success).length
    const success = successCount === apiKeys.length

    console.warn(`🏁 РЕЗУЛЬТАТ СОЗДАНИЯ API КЛЮЧЕЙ: ${successCount}/${apiKeys.length} успешно`)

    return {
      success,
      results,
      sellerData: primarySellerData,
    }
  }

  /**
   * Получает все активные API ключи организации
   */
  async getOrganizationApiKeys(organizationId: string) {
    return await prisma.apiKey.findMany({
      where: {
        organizationId,
        isActive: true,
      },
      select: {
        id: true,
        marketplace: true,
        isActive: true,
        validationData: true,
        createdAt: true,
        updatedAt: true,
      },
    })
  }

  /**
   * Деактивирует API ключ
   */
  async deactivateApiKey(apiKeyId: string): Promise<boolean> {
    try {
      await prisma.apiKey.update({
        where: { id: apiKeyId },
        data: { isActive: false },
      })
      return true
    } catch (error) {
      console.error('Ошибка деактивации API ключа:', error)
      return false
    }
  }
}

// Экспортируем синглтон для использования в резолверах
export const apiKeyUtility = new ApiKeyUtility()