/**
 * Program Configuration Service
 * Loads program config from database with JSON file fallback
 */
import * as fs from 'fs';
import * as path from 'path';
import { fileURLToPath } from 'url';
import { logger } from '../utils/logger';
import { prisma } from '../utils/prisma';
import type { VotingProgram } from '@gala/shared/types';

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

// Default config path (fallback)
const CONFIG_PATH = path.join(__dirname, '../../config/programs.json');

export interface ProgramConfig {
  id: string;
  name: string;
  teamName: string;
  performer?: string;
  order: number;
  remark?: string;
}

export interface AwardConfig {
  id: string;
  name: string;
  icon: string;
  order: number;
  remark?: string;
}

export interface ProgramSettings {
  allowLateCatch: boolean;
  maxVotesPerUser: number;
}

export interface ProgramConfigFile {
  programs: ProgramConfig[];
  awards: AwardConfig[];
  settings: ProgramSettings;
}

class ProgramConfigService {
  private config: ProgramConfigFile | null = null;
  private configPath: string;
  private useDatabase: boolean = true;

  constructor() {
    this.configPath = CONFIG_PATH;
  }

  /**
   * Load config from database or file
   */
  async load(): Promise<void> {
    try {
      // Try loading from database first
      const dbPrograms = await this.loadProgramsFromDb();
      const dbAwards = await this.loadAwardsFromDb();

      if (dbPrograms.length > 0 || dbAwards.length > 0) {
        this.useDatabase = true;
        this.config = {
          programs: dbPrograms,
          awards: dbAwards,
          settings: this.getDefaultSettings(),
        };
        logger.info({
          programCount: dbPrograms.length,
          awardCount: dbAwards.length,
          source: 'database'
        }, 'Program config loaded from database');
        return;
      }

      // Fallback to JSON file
      this.useDatabase = false;
      await this.loadFromFile();
    } catch (error) {
      logger.warn({ error }, 'Database not available, falling back to JSON file');
      this.useDatabase = false;
      await this.loadFromFile();
    }
  }

  /**
   * Load programs from database
   */
  private async loadProgramsFromDb(): Promise<ProgramConfig[]> {
    const programs = await prisma.program.findMany({
      where: { isActive: true },
      orderBy: { order: 'asc' },
    });
    return programs.map(p => ({
      id: p.id,
      name: p.name,
      teamName: p.teamName,
      performer: p.performer || undefined,
      order: p.order,
      remark: p.remark || undefined,
    }));
  }

  /**
   * Load awards from database
   */
  private async loadAwardsFromDb(): Promise<AwardConfig[]> {
    const awards = await prisma.award.findMany({
      where: { isActive: true },
      orderBy: { order: 'asc' },
    });
    return awards.map(a => ({
      id: a.id,
      name: a.name,
      icon: a.icon,
      order: a.order,
      remark: a.remark || undefined,
    }));
  }

  /**
   * Load config from JSON file
   */
  private async loadFromFile(): Promise<void> {
    try {
      if (fs.existsSync(this.configPath)) {
        const content = fs.readFileSync(this.configPath, 'utf-8');
        this.config = JSON.parse(content);
        logger.info({
          programCount: this.config?.programs.length,
          awardCount: this.config?.awards?.length || 0,
          source: 'file'
        }, 'Program config loaded from file');
      } else {
        logger.warn({ configPath: this.configPath }, 'Config file not found, using defaults');
        this.config = this.getDefaults();
      }
    } catch (error) {
      logger.error({ error }, 'Failed to load config from file');
      this.config = this.getDefaults();
    }
  }

  /**
   * Get default settings
   */
  private getDefaultSettings(): ProgramSettings {
    return {
      allowLateCatch: true,
      maxVotesPerUser: 7,
    };
  }

  /**
   * Get default configuration
   */
  private getDefaults(): ProgramConfigFile {
    return {
      programs: [
        { id: 'p1', name: '龙腾四海', teamName: '市场部', performer: '待定', order: 1, remark: '赞美节目如琥珀般凝固了某个经典、美好、闪光的瞬间。' },
        { id: 'p2', name: '金马奔腾', teamName: '技术部', performer: '待定', order: 2, remark: '强调节目留下了值得回味的"声音"。' },
        { id: 'p3', name: '春风得意', teamName: '人力资源部', performer: '待定', order: 3, remark: '赞美节目引发了跨越时代的共鸣。' },
        { id: 'p4', name: '鸿运当头', teamName: '财务部', performer: '待定', order: 4, remark: '形容节目用声音和表演编织了一个时代的梦境。' },
        { id: 'p5', name: '马到成功', teamName: '运营部', performer: '待定', order: 5, remark: '既指复刻了过去的潮流，也指创造了今晚的潮流。' },
        { id: 'p6', name: '一马当先', teamName: '产品部', performer: '待定', order: 6, remark: '强调节目的独特韵味与精心打磨。' },
        { id: 'p7', name: '万马奔腾', teamName: '设计部', performer: '待定', order: 7, remark: '赞美节目与"复古70-80"主题高度契合。' },
      ],
      awards: [
        { id: 'time_amber', name: '时光琥珀奖', icon: '🏆', order: 1 },
        { id: 'echo_years', name: '岁月留声奖', icon: '🎵', order: 2 },
        { id: 'resonance', name: '风华共鸣奖', icon: '🎭', order: 3 },
        { id: 'dream_weaver', name: '光影织梦奖', icon: '✨', order: 4 },
        { id: 'trend_mark', name: '潮流印记奖', icon: '🌊', order: 5 },
        { id: 'craftsmanship', name: '匠心独韵奖', icon: '💎', order: 6 },
        { id: 'in_sync', name: '同频时代奖', icon: '📻', order: 7 },
      ],
      settings: this.getDefaultSettings(),
    };
  }

  /**
   * Get all programs
   */
  getPrograms(): ProgramConfig[] {
    return this.config?.programs || this.getDefaults().programs;
  }

  /**
   * Get all awards
   */
  getAwards(): AwardConfig[] {
    return this.config?.awards || this.getDefaults().awards;
  }

  /**
   * Get award by id
   */
  getAwardById(id: string): AwardConfig | undefined {
    return this.getAwards().find(a => a.id === id);
  }

  /**
   * Convert config programs to VotingProgram format
   */
  getVotingPrograms(): VotingProgram[] {
    const programs = this.getPrograms();
    return programs.map(p => ({
      ...p,
      status: 'pending' as const,
      votes: 0,
      stamps: [],
    }));
  }

  /**
   * Get program by id
   */
  getProgramById(id: string): ProgramConfig | undefined {
    return this.getPrograms().find(p => p.id === id);
  }

  /**
   * Get settings
   */
  getSettings(): ProgramSettings {
    return this.config?.settings || this.getDefaultSettings();
  }

  /**
   * Update programs (database or file)
   */
  async updatePrograms(programs: ProgramConfig[]): Promise<{ success: boolean; error?: string }> {
    try {
      if (this.useDatabase) {
        return await this.updateProgramsInDb(programs);
      }
      return await this.updateProgramsInFile(programs);
    } catch (error) {
      logger.error({ error }, 'Failed to update programs');
      return { success: false, error: (error as Error).message };
    }
  }

  /**
   * Update programs in database
   */
  private async updateProgramsInDb(programs: ProgramConfig[]): Promise<{ success: boolean; error?: string }> {
    // Use transaction to update all programs
    await prisma.$transaction(async (tx) => {
      // Deactivate all existing programs
      await tx.program.updateMany({
        data: { isActive: false }
      });

      // Upsert each program
      for (const p of programs) {
        await tx.program.upsert({
          where: { id: p.id },
          create: {
            id: p.id,
            name: p.name,
            teamName: p.teamName,
            performer: p.performer || '',
            order: p.order,
            remark: p.remark,
            isActive: true,
          },
          update: {
            name: p.name,
            teamName: p.teamName,
            performer: p.performer || '',
            order: p.order,
            remark: p.remark,
            isActive: true,
          },
        });
      }
    });

    // Reload config
    await this.load();
    logger.info({ programCount: programs.length }, 'Programs updated in database');
    return { success: true };
  }

  /**
   * Update programs in file
   */
  private async updateProgramsInFile(programs: ProgramConfig[]): Promise<{ success: boolean; error?: string }> {
    if (!this.config) {
      this.config = this.getDefaults();
    }
    this.config.programs = programs;
    await this.saveToFile();
    logger.info({ programCount: programs.length }, 'Programs updated in file');
    return { success: true };
  }

  /**
   * Update awards (database or file)
   */
  async updateAwards(awards: AwardConfig[]): Promise<{ success: boolean; error?: string }> {
    try {
      if (this.useDatabase) {
        return await this.updateAwardsInDb(awards);
      }
      return await this.updateAwardsInFile(awards);
    } catch (error) {
      logger.error({ error }, 'Failed to update awards');
      return { success: false, error: (error as Error).message };
    }
  }

  /**
   * Update awards in database
   */
  private async updateAwardsInDb(awards: AwardConfig[]): Promise<{ success: boolean; error?: string }> {
    await prisma.$transaction(async (tx) => {
      await tx.award.updateMany({
        data: { isActive: false }
      });

      for (const a of awards) {
        await tx.award.upsert({
          where: { id: a.id },
          create: {
            id: a.id,
            name: a.name,
            icon: a.icon,
            order: a.order,
            remark: a.remark,
            isActive: true,
          },
          update: {
            name: a.name,
            icon: a.icon,
            order: a.order,
            remark: a.remark,
            isActive: true,
          },
        });
      }
    });

    await this.load();
    logger.info({ awardCount: awards.length }, 'Awards updated in database');
    return { success: true };
  }

  /**
   * Update awards in file
   */
  private async updateAwardsInFile(awards: AwardConfig[]): Promise<{ success: boolean; error?: string }> {
    if (!this.config) {
      this.config = this.getDefaults();
    }
    this.config.awards = awards;
    await this.saveToFile();
    logger.info({ awardCount: awards.length }, 'Awards updated in file');
    return { success: true };
  }

  /**
   * Update settings
   */
  async updateSettings(settings: Partial<ProgramSettings>): Promise<{ success: boolean; error?: string }> {
    try {
      if (!this.config) {
        this.config = this.getDefaults();
      }
      this.config.settings = { ...this.config.settings, ...settings };
      if (!this.useDatabase) {
        await this.saveToFile();
      }
      logger.info({ settings: this.config.settings }, 'Program settings updated');
      return { success: true };
    } catch (error) {
      logger.error({ error }, 'Failed to update settings');
      return { success: false, error: (error as Error).message };
    }
  }

  /**
   * Save config to file
   */
  private async saveToFile(): Promise<void> {
    const content = JSON.stringify(this.config, null, 2);
    fs.writeFileSync(this.configPath, content, 'utf-8');
  }

  /**
   * Get full config
   */
  getFullConfig(): ProgramConfigFile {
    return this.config || this.getDefaults();
  }

  /**
   * Check if using database
   */
  isUsingDatabase(): boolean {
    return this.useDatabase;
  }
}

export const programConfigService = new ProgramConfigService();