// ==================== EMAIL PROVIDER SERVICE ====================

import { PrismaClient } from '@prisma/client';
import { decrypt } from '../../utils/encryption.js';
import {
  IEmailProvider,
  EmailProviderConfig,
  EmailExistsResult,
  EmailOperationResult,
  CreateEmailParams,
} from './types.js';
import { PleskEmailProvider } from './pleskProvider.js';

const prisma = new PrismaClient();

// Factory-Funktion um den richtigen Provider zu erstellen
function createProvider(config: EmailProviderConfig): IEmailProvider {
  switch (config.type) {
    case 'PLESK':
      return new PleskEmailProvider(config);
    case 'CPANEL':
      // TODO: cPanel Provider implementieren
      throw new Error('cPanel Provider noch nicht implementiert');
    case 'DIRECTADMIN':
      // TODO: DirectAdmin Provider implementieren
      throw new Error('DirectAdmin Provider noch nicht implementiert');
    default:
      throw new Error(`Unbekannter Provider-Typ: ${config.type}`);
  }
}

// ==================== CONFIG CRUD ====================

export async function getAllProviderConfigs() {
  return prisma.emailProviderConfig.findMany({
    orderBy: [{ isDefault: 'desc' }, { name: 'asc' }],
  });
}

export async function getProviderConfigById(id: number) {
  return prisma.emailProviderConfig.findUnique({
    where: { id },
  });
}

export async function getDefaultProviderConfig() {
  return prisma.emailProviderConfig.findFirst({
    where: { isActive: true, isDefault: true },
  });
}

export async function getActiveProviderConfig() {
  // Erst Default-Provider versuchen, dann irgendeinen aktiven
  const defaultProvider = await getDefaultProviderConfig();
  if (defaultProvider) return defaultProvider;

  return prisma.emailProviderConfig.findFirst({
    where: { isActive: true },
  });
}

export interface CreateProviderConfigData {
  name: string;
  type: 'PLESK' | 'CPANEL' | 'DIRECTADMIN';
  apiUrl: string;
  apiKey?: string;
  username?: string;
  password?: string;
  domain: string;
  defaultForwardEmail?: string;
  isActive?: boolean;
  isDefault?: boolean;
}

export async function createProviderConfig(data: CreateProviderConfigData) {
  // Falls isDefault=true, alle anderen auf false setzen
  if (data.isDefault) {
    await prisma.emailProviderConfig.updateMany({
      where: { isDefault: true },
      data: { isDefault: false },
    });
  }

  // Passwort verschlüsseln falls vorhanden
  const { encrypt } = await import('../../utils/encryption.js');
  const passwordEncrypted = data.password ? encrypt(data.password) : null;

  return prisma.emailProviderConfig.create({
    data: {
      name: data.name,
      type: data.type,
      apiUrl: data.apiUrl,
      apiKey: data.apiKey || null,
      username: data.username || null,
      passwordEncrypted,
      domain: data.domain,
      defaultForwardEmail: data.defaultForwardEmail || null,
      isActive: data.isActive ?? true,
      isDefault: data.isDefault ?? false,
    },
  });
}

export async function updateProviderConfig(
  id: number,
  data: Partial<CreateProviderConfigData>
) {
  // Falls isDefault=true, alle anderen auf false setzen
  if (data.isDefault) {
    await prisma.emailProviderConfig.updateMany({
      where: { isDefault: true, id: { not: id } },
      data: { isDefault: false },
    });
  }

  const updateData: Record<string, unknown> = {};

  if (data.name !== undefined) updateData.name = data.name;
  if (data.type !== undefined) updateData.type = data.type;
  if (data.apiUrl !== undefined) updateData.apiUrl = data.apiUrl;
  if (data.apiKey !== undefined) updateData.apiKey = data.apiKey || null;
  if (data.username !== undefined) updateData.username = data.username || null;
  if (data.domain !== undefined) updateData.domain = data.domain;
  if (data.defaultForwardEmail !== undefined)
    updateData.defaultForwardEmail = data.defaultForwardEmail || null;
  if (data.isActive !== undefined) updateData.isActive = data.isActive;
  if (data.isDefault !== undefined) updateData.isDefault = data.isDefault;

  // Passwort-Logik:
  // - Wenn neues Passwort übergeben → verschlüsseln und speichern
  // - Wenn Benutzername gelöscht wird → Passwort auch löschen (gehören zusammen)
  if (data.password) {
    const { encrypt } = await import('../../utils/encryption.js');
    updateData.passwordEncrypted = encrypt(data.password);
  } else if (data.username !== undefined && !data.username) {
    // Benutzername wird gelöscht → Passwort auch löschen
    updateData.passwordEncrypted = null;
  }

  return prisma.emailProviderConfig.update({
    where: { id },
    data: updateData,
  });
}

export async function deleteProviderConfig(id: number) {
  return prisma.emailProviderConfig.delete({
    where: { id },
  });
}

// ==================== EMAIL OPERATIONS ====================

// Provider-Instanz aus DB-Config erstellen
async function getProviderInstance(): Promise<IEmailProvider> {
  const dbConfig = await getActiveProviderConfig();

  if (!dbConfig) {
    throw new Error('Kein aktiver Email-Provider konfiguriert');
  }

  // Passwort entschlüsseln
  let password: string | undefined;
  if (dbConfig.passwordEncrypted) {
    try {
      password = decrypt(dbConfig.passwordEncrypted);
    } catch {
      console.error('Konnte Passwort nicht entschlüsseln');
    }
  }

  const config: EmailProviderConfig = {
    id: dbConfig.id,
    name: dbConfig.name,
    type: dbConfig.type as 'PLESK' | 'CPANEL' | 'DIRECTADMIN',
    apiUrl: dbConfig.apiUrl,
    apiKey: dbConfig.apiKey || undefined,
    username: dbConfig.username || undefined,
    password,
    domain: dbConfig.domain,
    defaultForwardEmail: dbConfig.defaultForwardEmail || undefined,
    isActive: dbConfig.isActive,
    isDefault: dbConfig.isDefault,
  };

  return createProvider(config);
}

// Prüfen ob eine E-Mail existiert
export async function checkEmailExists(localPart: string): Promise<EmailExistsResult> {
  try {
    const provider = await getProviderInstance();
    return provider.emailExists(localPart);
  } catch (error) {
    console.error('checkEmailExists error:', error);
    return { exists: false };
  }
}

// E-Mail erstellen mit Weiterleitungen
export async function provisionEmail(
  localPart: string,
  customerEmail: string
): Promise<EmailOperationResult> {
  try {
    const provider = await getProviderInstance();
    const config = await getActiveProviderConfig();

    // Weiterleitungsziele zusammenstellen
    const forwardTargets: string[] = [customerEmail];

    // Unsere eigene Weiterleitungsadresse hinzufügen falls konfiguriert
    if (config?.defaultForwardEmail) {
      forwardTargets.push(config.defaultForwardEmail);
    }

    // Prüfen ob existiert
    const exists = await provider.emailExists(localPart);
    if (exists.exists) {
      return {
        success: true,
        message: `E-Mail ${exists.email} existiert bereits`,
      };
    }

    // Erstellen
    const result = await provider.createEmail({
      localPart,
      forwardTargets,
    });

    return result;
  } catch (error) {
    const errorMessage = error instanceof Error ? error.message : 'Unbekannter Fehler';
    return {
      success: false,
      error: errorMessage,
    };
  }
}

// E-Mail löschen
export async function deprovisionEmail(localPart: string): Promise<EmailOperationResult> {
  try {
    const provider = await getProviderInstance();
    return provider.deleteEmail(localPart);
  } catch (error) {
    const errorMessage = error instanceof Error ? error.message : 'Unbekannter Fehler';
    return {
      success: false,
      error: errorMessage,
    };
  }
}

// E-Mail umbenennen
export async function renameProvisionedEmail(
  oldLocalPart: string,
  newLocalPart: string
): Promise<EmailOperationResult> {
  try {
    const provider = await getProviderInstance();
    return provider.renameEmail({ oldLocalPart, newLocalPart });
  } catch (error) {
    const errorMessage = error instanceof Error ? error.message : 'Unbekannter Fehler';
    return {
      success: false,
      error: errorMessage,
    };
  }
}

// Domain aus aktivem Provider holen
export async function getProviderDomain(): Promise<string | null> {
  const config = await getActiveProviderConfig();
  return config?.domain || null;
}

// Provider-Instanz aus übergebener Config erstellen (für Tests mit ungespeicherten Daten)
function createProviderFromFormData(data: {
  type: 'PLESK' | 'CPANEL' | 'DIRECTADMIN';
  apiUrl: string;
  apiKey?: string;
  username?: string;
  password?: string;
  domain: string;
}): IEmailProvider {
  const config: EmailProviderConfig = {
    id: 0,
    name: 'Test',
    type: data.type,
    apiUrl: data.apiUrl,
    apiKey: data.apiKey,
    username: data.username,
    password: data.password,
    domain: data.domain,
    isActive: true,
    isDefault: false,
  };
  return createProvider(config);
}

// Provider-Instanz aus DB-Config per ID erstellen
async function getProviderInstanceById(id: number): Promise<IEmailProvider> {
  const dbConfig = await getProviderConfigById(id);

  if (!dbConfig) {
    throw new Error('Email-Provider nicht gefunden');
  }

  // Passwort entschlüsseln
  let password: string | undefined;
  if (dbConfig.passwordEncrypted) {
    try {
      password = decrypt(dbConfig.passwordEncrypted);
    } catch {
      console.error('Konnte Passwort nicht entschlüsseln');
    }
  }

  const config: EmailProviderConfig = {
    id: dbConfig.id,
    name: dbConfig.name,
    type: dbConfig.type as 'PLESK' | 'CPANEL' | 'DIRECTADMIN',
    apiUrl: dbConfig.apiUrl,
    apiKey: dbConfig.apiKey || undefined,
    username: dbConfig.username || undefined,
    password,
    domain: dbConfig.domain,
    defaultForwardEmail: dbConfig.defaultForwardEmail || undefined,
    isActive: dbConfig.isActive,
    isDefault: dbConfig.isDefault,
  };

  return createProvider(config);
}

// Provider-Verbindung testen (mit ID, Formulardaten oder Default-Provider)
export async function testProviderConnection(options?: {
  id?: number;
  testData?: {
    type: 'PLESK' | 'CPANEL' | 'DIRECTADMIN';
    apiUrl: string;
    apiKey?: string;
    username?: string;
    password?: string;
    domain: string;
  };
}): Promise<EmailOperationResult> {
  try {
    let provider: IEmailProvider;

    if (options?.testData) {
      // Mit übergebenen Daten testen (z.B. aus Modal beim Neuanlegen)
      provider = createProviderFromFormData(options.testData);
    } else if (options?.id) {
      // Gespeicherten Provider per ID testen
      provider = await getProviderInstanceById(options.id);
    } else {
      // Default-Provider testen
      provider = await getProviderInstance();
    }

    // Expliziter Verbindungstest (wirft Fehler bei Auth-Problemen)
    await provider.testConnection();

    return {
      success: true,
      message: 'Verbindung zum Email-Provider erfolgreich',
    };
  } catch (error) {
    const errorMessage = error instanceof Error ? error.message : 'Unbekannter Fehler';
    return {
      success: false,
      error: errorMessage,
    };
  }
}