import MemberTransferConfig from '../models/MemberTransferConfig.js';
import { checkAccess } from '../utils/userUtils.js';
import { devLog } from '../utils/logger.js';

class MemberTransferConfigService {
    /**
     * Ruft die Konfiguration für einen Verein ab
     */
    async getConfig(userToken, clubId) {
        try {
            await checkAccess(userToken, clubId);
            
            const config = await MemberTransferConfig.findOne({
                where: { clubId }
            });

            if (!config) {
                return {
                    status: 404,
                    response: {
                        success: false,
                        message: 'Keine Konfiguration gefunden'
                    }
                };
            }

            // Login-Credentials entschlüsseln
            const loginCredentials = config.getLoginCredentials();

            return {
                status: 200,
                response: {
                    success: true,
                    config: {
                        id: config.id,
                        clubId: config.clubId,
                        server: config.server,
                        loginEndpoint: config.loginEndpoint,
                        loginFormat: config.loginFormat,
                        loginCredentials: loginCredentials || {},
                        transferEndpoint: config.transferEndpoint,
                        transferMethod: config.transferMethod,
                        transferFormat: config.transferFormat,
                        transferTemplate: config.transferTemplate,
                        useBulkMode: config.useBulkMode,
                        bulkWrapperTemplate: config.bulkWrapperTemplate
                    }
                }
            };
        } catch (error) {
            devLog('[getConfig] Error:', error);
            return {
                status: 500,
                response: {
                    success: false,
                    error: 'Fehler beim Laden der Konfiguration: ' + error.message
                }
            };
        }
    }

    /**
     * Speichert oder aktualisiert die Konfiguration
     */
    async saveConfig(userToken, clubId, configData) {
        try {
            await checkAccess(userToken, clubId);

            // Validierung
            if (!configData.server) {
                return {
                    status: 400,
                    response: {
                        success: false,
                        error: 'Server-Basis-URL ist erforderlich'
                    }
                };
            }

            if (!configData.transferEndpoint) {
                return {
                    status: 400,
                    response: {
                        success: false,
                        error: 'Übertragungs-Endpoint ist erforderlich'
                    }
                };
            }

            if (!configData.transferTemplate) {
                return {
                    status: 400,
                    response: {
                        success: false,
                        error: 'Übertragungs-Template ist erforderlich'
                    }
                };
            }

            // Prüfen, ob bereits eine Konfiguration existiert
            let config = await MemberTransferConfig.findOne({
                where: { clubId }
            });

            const configToSave = {
                clubId: clubId,
                server: configData.server,
                loginEndpoint: configData.loginEndpoint || null,
                loginFormat: configData.loginFormat || 'json',
                transferEndpoint: configData.transferEndpoint,
                transferMethod: configData.transferMethod || 'POST',
                transferFormat: configData.transferFormat || 'json',
                transferTemplate: configData.transferTemplate,
                useBulkMode: configData.useBulkMode || false,
                bulkWrapperTemplate: configData.bulkWrapperTemplate || null
            };

            if (config) {
                // Update
                config.server = configToSave.server;
                config.loginEndpoint = configToSave.loginEndpoint;
                config.loginFormat = configToSave.loginFormat;
                config.transferEndpoint = configToSave.transferEndpoint;
                config.transferMethod = configToSave.transferMethod;
                config.transferFormat = configToSave.transferFormat;
                config.transferTemplate = configToSave.transferTemplate;
                config.useBulkMode = configToSave.useBulkMode;
                config.bulkWrapperTemplate = configToSave.bulkWrapperTemplate;

                // Login-Credentials setzen (nur wenn vorhanden)
                if (configData.loginCredentials) {
                    config.setLoginCredentials(configData.loginCredentials);
                } else {
                    // Wenn keine Credentials übergeben wurden, aber welche vorhanden sind, behalten
                    // Nur löschen, wenn explizit null/undefined übergeben wurde
                    if (configData.loginCredentials === null || configData.loginCredentials === undefined) {
                        config.encryptedLoginCredentials = null;
                    }
                }

                await config.save();
            } else {
                // Create
                config = await MemberTransferConfig.create(configToSave);
                
                // Login-Credentials setzen (nur wenn vorhanden)
                if (configData.loginCredentials) {
                    config.setLoginCredentials(configData.loginCredentials);
                    await config.save();
                }
            }

            return {
                status: 200,
                response: {
                    success: true,
                    message: 'Konfiguration erfolgreich gespeichert',
                    config: {
                        id: config.id,
                        clubId: config.clubId,
                        server: config.server,
                        loginEndpoint: config.loginEndpoint,
                        loginFormat: config.loginFormat,
                        transferEndpoint: config.transferEndpoint,
                        transferMethod: config.transferMethod,
                        transferFormat: config.transferFormat,
                        transferTemplate: config.transferTemplate,
                        useBulkMode: config.useBulkMode,
                        bulkWrapperTemplate: config.bulkWrapperTemplate
                    }
                }
            };
        } catch (error) {
            devLog('[saveConfig] Error:', error);
            return {
                status: 500,
                response: {
                    success: false,
                    error: 'Fehler beim Speichern der Konfiguration: ' + error.message
                }
            };
        }
    }

    /**
     * Löscht die Konfiguration
     */
    async deleteConfig(userToken, clubId) {
        try {
            await checkAccess(userToken, clubId);

            const deleted = await MemberTransferConfig.destroy({
                where: { clubId }
            });

            if (deleted === 0) {
                return {
                    status: 404,
                    response: {
                        success: false,
                        message: 'Keine Konfiguration gefunden'
                    }
                };
            }

            return {
                status: 200,
                response: {
                    success: true,
                    message: 'Konfiguration erfolgreich gelöscht'
                }
            };
        } catch (error) {
            devLog('[deleteConfig] Error:', error);
            return {
                status: 500,
                response: {
                    success: false,
                    error: 'Fehler beim Löschen der Konfiguration: ' + error.message
                }
            };
        }
    }
}

export default new MemberTransferConfigService();

