/**
 * AI 프로세서 - AI와의 통신 및 셀 적용 로직 처리
 * - 프롬프트를 AI에게 전송하고 응답 받기
 * - 응답 데이터를 파싱하여 각 셀에 수식 적용
 * - 10ms 인터벌로 순차적 셀 적용
 */

// presets 환경에서는 FUniver import 불필요 (deprecated)
// import { FUniver } from "@univerjs/core/facade";
import { useAppStore } from "../stores/useAppStore";

// AI 응답 데이터 타입 정의
export interface AIResponse {
  targetCell: string;
  formula: string;
}

// AI 프로세서 결과 타입
export interface ProcessResult {
  success: boolean;
  message: string;
  appliedCells?: string[];
  errors?: string[];
}

/**
 * AI 프로세서 클래스
 * - SRP: AI 통신과 셀 적용만 담당
 * - 테스트 모드와 실제 AI 모드 지원
 */
export class AIProcessor {
  private isProcessing = false;

  /**
   * 현재 처리 중인지 확인
   */
  public isCurrentlyProcessing(): boolean {
    return this.isProcessing;
  }

  /**
   * 테스트용 고정 데이터 생성
   * 실제 AI 연동 전 테스트를 위한 더미 데이터
   */
  private generateTestData(): AIResponse[] {
    return [
      {
        targetCell: "E13",
        formula: "=C13+D13",
      },
      {
        targetCell: "E14",
        formula: "=C14+D14",
      },
      {
        targetCell: "E15",
        formula: "=C15+D15",
      },
    ];
  }

  /**
   * AI에게 프롬프트 전송 (현재는 테스트 모드)
   * @param prompt - 사용자 입력 프롬프트
   * @param isTestMode - 테스트 모드 여부 (기본값: true)
   */
  private async sendToAI(
    prompt: string,
    isTestMode: boolean = true,
  ): Promise<AIResponse[]> {
    console.log("🤖 AI 프로세싱 시작:", prompt);

    if (isTestMode) {
      console.log("🧪 테스트 모드: 고정 데이터 사용");

      // 실제 AI 호출을 시뮬레이션하기 위한 딜레이
      await new Promise((resolve) => setTimeout(resolve, 1500));

      return this.generateTestData();
    }

    // TODO: 실제 AI API 호출 로직
    // const response = await fetch('/api/ai', {
    //   method: 'POST',
    //   headers: { 'Content-Type': 'application/json' },
    //   body: JSON.stringify({ prompt })
    // });
    // return await response.json();

    throw new Error("실제 AI API 연동은 아직 구현되지 않았습니다.");
  }

  /**
   * 단일 셀에 수식 적용
   * @param univerAPI - FUniver API 인스턴스
   * @param targetCell - 대상 셀 주소 (예: "E13")
   * @param formula - 적용할 수식 (예: "=C13+D13")
   */
  private async applyCellFormula(
    univerAPI: any,
    targetCell: string,
    formula: string,
  ): Promise<boolean> {
    try {
      if (!univerAPI) {
        throw new Error("Univer API가 생성되지 않았습니다.");
      }

      const activeWorkbook = univerAPI.getActiveWorkbook();
      if (!activeWorkbook) {
        throw new Error("활성 워크북을 찾을 수 없습니다.");
      }

      const activeSheet = activeWorkbook.getActiveSheet();
      if (!activeSheet) {
        throw new Error("활성 시트를 찾을 수 없습니다.");
      }

      // 셀 주소를 행/열 좌표로 변환
      const cellCoords = this.parseCellAddress(targetCell);

      // 👉 셀 선택(하이라이트) 추가
      // const selectionService = activeSheet.getSelection?.();
      // if (selectionService?.setSelections) {
      //   selectionService.setSelections([
      //     {
      //       startRow: cellCoords.row,
      //       startColumn: cellCoords.col,
      //       endRow: cellCoords.row,
      //       endColumn: cellCoords.col,
      //     },
      //   ]);
      // }

      // 👉 셀 선택 (Facade API 기반)
      try {
        const activeWorkbook = univerAPI.getActiveWorkbook();
        if (activeWorkbook) {
          const activeSheet = activeWorkbook.getActiveSheet();
          if (activeSheet) {
            try {
              // Facade API의 표준 방식: Range를 통한 셀 선택
              const cellRange = activeSheet.getRange(targetCell);
              if (cellRange) {
                // 다양한 선택 방법 시도
                if (typeof cellRange.select === "function") {
                  cellRange.select();
                  console.log(`🎯 셀 ${targetCell} 선택 완료 (range.select)`);
                } else if (
                  typeof activeWorkbook.setActiveRange === "function"
                ) {
                  activeWorkbook.setActiveRange(cellRange);
                  console.log(`🎯 셀 ${targetCell} 활성 범위 설정 완료`);
                } else if (typeof activeSheet.activate === "function") {
                  // 워크시트 활성화 후 셀 포커스
                  activeSheet.activate();
                  console.log(`🎯 워크시트 활성화 후 셀 ${targetCell} 포커스`);
                } else {
                  console.log(`🔍 지원하는 선택 메소드를 찾을 수 없습니다.`);

                  // 디버깅을 위해 사용 가능한 메소드 출력
                  const rangeMethods = Object.getOwnPropertyNames(cellRange)
                    .filter(
                      (name) => typeof (cellRange as any)[name] === "function",
                    )
                    .filter(
                      (name) =>
                        name.toLowerCase().includes("select") ||
                        name.toLowerCase().includes("active"),
                    );

                  const workbookMethods = Object.getOwnPropertyNames(
                    activeWorkbook,
                  )
                    .filter(
                      (name) =>
                        typeof (activeWorkbook as any)[name] === "function",
                    )
                    .filter(
                      (name) =>
                        name.toLowerCase().includes("select") ||
                        name.toLowerCase().includes("active"),
                    );

                  console.log(`🔍 Range 선택 관련 메소드:`, rangeMethods);
                  console.log(`🔍 Workbook 선택 관련 메소드:`, workbookMethods);
                }
              } else {
                console.warn(`⚠️ ${targetCell} 범위를 가져올 수 없음`);
              }
            } catch (rangeError) {
              console.warn(`⚠️ Range 기반 선택 실패:`, rangeError);

              // 폴백: 좌표 기반 시도
              try {
                if (typeof activeSheet.setActiveCell === "function") {
                  activeSheet.setActiveCell(cellCoords.row, cellCoords.col);
                  console.log(`🎯 셀 ${targetCell} 좌표 기반 선택 완료`);
                } else {
                  console.log(`🔍 setActiveCell 메소드 없음`);
                }
              } catch (coordError) {
                console.warn(`⚠️ 좌표 기반 선택도 실패:`, coordError);
              }
            }
          } else {
            console.warn(`⚠️ ActiveSheet를 가져올 수 없음`);
          }
        } else {
          console.warn(`⚠️ ActiveWorkbook을 가져올 수 없음`);
        }
      } catch (selectionError) {
        console.warn(`⚠️ 셀 ${targetCell} 선택 전체 실패:`, selectionError);
      }

      // 셀에 수식 설정
      const range = activeSheet.getRange(cellCoords.row, cellCoords.col, 1, 1);
      range.setValue(formula);

      console.log(`✅ 셀 ${targetCell} 수식 적용 및 하이라이트 완료`);
      return true;
    } catch (error) {
      console.error(`❌ 셀 ${targetCell} 수식 적용 실패:`, error);
      return false;
    }
  }

  /**
   * 셀 주소를 행/열 좌표로 변환
   * @param cellAddress - 셀 주소 (예: "E13")
   * @returns 행/열 좌표 객체
   */
  private parseCellAddress(cellAddress: string): { row: number; col: number } {
    const match = cellAddress.match(/^([A-Z]+)(\d+)$/);
    if (!match) {
      throw new Error(`잘못된 셀 주소 형식: ${cellAddress}`);
    }

    const colLetters = match[1];
    const rowNumber = parseInt(match[2]);

    // 컬럼 문자를 숫자로 변환 (A=0, B=1, ..., Z=25, AA=26, ...)
    let col = 0;
    for (let i = 0; i < colLetters.length; i++) {
      col = col * 26 + (colLetters.charCodeAt(i) - 65 + 1);
    }
    col -= 1; // 0-based 인덱스로 변환

    return {
      row: rowNumber - 1, // 0-based 인덱스로 변환
      col: col,
    };
  }

  /**
   * 메인 프로세싱 함수
   * @param prompt - 사용자 프롬프트
   * @param isTestMode - 테스트 모드 여부
   */
  public async processPrompt(
    prompt: string,
    isTestMode: boolean = true,
  ): Promise<ProcessResult> {
    if (this.isProcessing) {
      return {
        success: false,
        message: "이미 처리 중입니다. 잠시 후 다시 시도해주세요.",
      };
    }

    // presets 환경에서는 전역 상태에서 univerAPI를 직접 가져옴
    const globalState = (window as any)["__GLOBAL_UNIVER_STATE__"];
    if (!globalState?.instance || !globalState?.univerAPI) {
      return {
        success: false,
        message: "Univer 인스턴스 또는 API를 찾을 수 없습니다.",
      };
    }
    const univerAPI = globalState.univerAPI;

    this.isProcessing = true;
    // zustand store에 연산 시작 알림
    try {
      useAppStore.getState().setProcessing(true);
    } catch (e) {
      /* SSR/테스트 환경 무시 */
    }
    const appliedCells: string[] = [];
    const errors: string[] = [];

    try {
      console.log("🚀 AI 프롬프트 처리 시작");
      console.log("📝 프롬프트:", prompt);

      // 1. AI에게 프롬프트 전송
      const aiResponses = await this.sendToAI(prompt, isTestMode);
      console.log("🤖 AI 응답 받음:", aiResponses);

      if (!Array.isArray(aiResponses) || aiResponses.length === 0) {
        throw new Error("AI 응답이 올바르지 않습니다.");
      }

      // 2. 각 셀에 10ms 간격으로 순차 적용
      console.log(`📊 총 ${aiResponses.length}개 셀에 수식 적용 시작`);

      for (let i = 0; i < aiResponses.length; i++) {
        const response = aiResponses[i];

        try {
          const success = await this.applyCellFormula(
            univerAPI,
            response.targetCell,
            response.formula,
          );

          if (success) {
            appliedCells.push(response.targetCell);
            console.log(
              `✅ [${i + 1}/${aiResponses.length}] ${response.targetCell} 적용 완료`,
            );
          } else {
            errors.push(`${response.targetCell}: 수식 적용 실패`);
          }
        } catch (error) {
          const errorMsg = `${response.targetCell}: ${error instanceof Error ? error.message : "알 수 없는 오류"}`;
          errors.push(errorMsg);
          console.error(`❌ [${i + 1}/${aiResponses.length}] ${errorMsg}`);
        }

        // 마지막 항목이 아니면 10ms 대기
        if (i < aiResponses.length - 1) {
          await new Promise((resolve) => setTimeout(resolve, 1000));
        }
      }

      const successCount = appliedCells.length;
      const errorCount = errors.length;

      console.log(`🎉 처리 완료: 성공 ${successCount}개, 실패 ${errorCount}개`);

      return {
        success: successCount > 0,
        message: `총 ${aiResponses.length}개 중 ${successCount}개 셀에 수식을 성공적으로 적용했습니다.${errorCount > 0 ? ` (실패: ${errorCount}개)` : ""}`,
        appliedCells,
        errors: errorCount > 0 ? errors : undefined,
      };
    } catch (error) {
      const errorMessage =
        error instanceof Error
          ? error.message
          : "알 수 없는 오류가 발생했습니다.";
      console.error("❌ AI 프롬프트 처리 실패:", error);

      return {
        success: false,
        message: `처리 실패: ${errorMessage}`,
        appliedCells: appliedCells.length > 0 ? appliedCells : undefined,
        errors: [...errors, errorMessage],
      };
    } finally {
      this.isProcessing = false;
      // zustand store에 연산 종료 알림
      try {
        useAppStore.getState().setProcessing(false);
      } catch (e) {
        /* SSR/테스트 환경 무시 */
      }
      console.log("🏁 AI 프롬프트 처리 종료");
    }
  }
}

/**
 * 전역 AI 프로세서 인스턴스
 * - 싱글톤 패턴으로 관리
 */
export const aiProcessor = new AIProcessor();
