import { PrismaClient } from "@prisma/client";
import { logger } from "../utils/logger";
import {
  Language,
  LangKey,
  LangText,
  CreateLanguageRequest,
  UpdateLanguageRequest,
  CreateLangKeyRequest,
  UpdateLangKeyRequest,
  SaveLangTextsRequest,
  GetLangKeysParams,
  GetUserTextParams,
  BatchTranslationRequest,
  ApiResponse,
} from "../types/multilang";

const prisma = new PrismaClient();

export class MultiLangService {
  constructor() {}

  /**
   * 언어 목록 조회
   */
  async getLanguages(): Promise<Language[]> {
    try {
      logger.info("언어 목록 조회 시작");

      const languages = await prisma.language_master.findMany({
        orderBy: [{ sort_order: "asc" }, { lang_code: "asc" }],
        select: {
          lang_code: true,
          lang_name: true,
          lang_native: true,
          is_active: true,
          sort_order: true,
          created_date: true,
          created_by: true,
          updated_date: true,
          updated_by: true,
        },
      });

      const mappedLanguages: Language[] = languages.map((lang) => ({
        langCode: lang.lang_code,
        langName: lang.lang_name,
        langNative: lang.lang_native,
        isActive: lang.is_active || "N",
        sortOrder: lang.sort_order ?? undefined,
        createdDate: lang.created_date || undefined,
        createdBy: lang.created_by || undefined,
        updatedDate: lang.updated_date || undefined,
        updatedBy: lang.updated_by || undefined,
      }));

      logger.info(`언어 목록 조회 완료: ${mappedLanguages.length}개`);
      return mappedLanguages;
    } catch (error) {
      logger.error("언어 목록 조회 중 오류 발생:", error);
      throw new Error(
        `언어 목록 조회 실패: ${error instanceof Error ? error.message : "Unknown error"}`
      );
    }
  }

  /**
   * 언어 생성
   */
  async createLanguage(languageData: CreateLanguageRequest): Promise<Language> {
    try {
      logger.info("언어 생성 시작", { languageData });

      // 중복 체크
      const existingLanguage = await prisma.language_master.findUnique({
        where: { lang_code: languageData.langCode },
      });

      if (existingLanguage) {
        throw new Error(
          `이미 존재하는 언어 코드입니다: ${languageData.langCode}`
        );
      }

      // 언어 생성
      const createdLanguage = await prisma.language_master.create({
        data: {
          lang_code: languageData.langCode,
          lang_name: languageData.langName,
          lang_native: languageData.langNative,
          is_active: languageData.isActive || "Y",
          sort_order: languageData.sortOrder || 0,
          created_by: languageData.createdBy || "system",
          updated_by: languageData.updatedBy || "system",
        },
      });

      logger.info("언어 생성 완료", { langCode: createdLanguage.lang_code });

      return {
        langCode: createdLanguage.lang_code,
        langName: createdLanguage.lang_name,
        langNative: createdLanguage.lang_native,
        isActive: createdLanguage.is_active || "N",
        sortOrder: createdLanguage.sort_order ?? undefined,
        createdDate: createdLanguage.created_date || undefined,
        createdBy: createdLanguage.created_by || undefined,
        updatedDate: createdLanguage.updated_date || undefined,
        updatedBy: createdLanguage.updated_by || undefined,
      };
    } catch (error) {
      logger.error("언어 생성 중 오류 발생:", error);
      throw new Error(
        `언어 생성 실패: ${error instanceof Error ? error.message : "Unknown error"}`
      );
    }
  }

  /**
   * 언어 수정
   */
  async updateLanguage(
    langCode: string,
    languageData: UpdateLanguageRequest
  ): Promise<Language> {
    try {
      logger.info("언어 수정 시작", { langCode, languageData });

      // 기존 언어 확인
      const existingLanguage = await prisma.language_master.findUnique({
        where: { lang_code: langCode },
      });

      if (!existingLanguage) {
        throw new Error(`언어를 찾을 수 없습니다: ${langCode}`);
      }

      // 언어 수정
      const updatedLanguage = await prisma.language_master.update({
        where: { lang_code: langCode },
        data: {
          ...(languageData.langName && { lang_name: languageData.langName }),
          ...(languageData.langNative && {
            lang_native: languageData.langNative,
          }),
          ...(languageData.isActive && { is_active: languageData.isActive }),
          ...(languageData.sortOrder !== undefined && {
            sort_order: languageData.sortOrder,
          }),
          updated_by: languageData.updatedBy || "system",
        },
      });

      logger.info("언어 수정 완료", { langCode });

      return {
        langCode: updatedLanguage.lang_code,
        langName: updatedLanguage.lang_name,
        langNative: updatedLanguage.lang_native,
        isActive: updatedLanguage.is_active || "N",
        sortOrder: updatedLanguage.sort_order ?? undefined,
        createdDate: updatedLanguage.created_date || undefined,
        createdBy: updatedLanguage.created_by || undefined,
        updatedDate: updatedLanguage.updated_date || undefined,
        updatedBy: updatedLanguage.updated_by || undefined,
      };
    } catch (error) {
      logger.error("언어 수정 중 오류 발생:", error);
      throw new Error(
        `언어 수정 실패: ${error instanceof Error ? error.message : "Unknown error"}`
      );
    }
  }

  /**
   * 언어 상태 토글
   */
  async toggleLanguage(langCode: string): Promise<string> {
    try {
      logger.info("언어 상태 토글 시작", { langCode });

      // 현재 언어 조회
      const currentLanguage = await prisma.language_master.findUnique({
        where: { lang_code: langCode },
        select: { is_active: true },
      });

      if (!currentLanguage) {
        throw new Error(`언어를 찾을 수 없습니다: ${langCode}`);
      }

      const newStatus = currentLanguage.is_active === "Y" ? "N" : "Y";

      // 상태 업데이트
      await prisma.language_master.update({
        where: { lang_code: langCode },
        data: {
          is_active: newStatus,
          updated_by: "system",
        },
      });

      const result = newStatus === "Y" ? "활성화" : "비활성화";
      logger.info("언어 상태 토글 완료", { langCode, result });

      return result;
    } catch (error) {
      logger.error("언어 상태 토글 중 오류 발생:", error);
      throw new Error(
        `언어 상태 토글 실패: ${error instanceof Error ? error.message : "Unknown error"}`
      );
    }
  }

  /**
   * 다국어 키 목록 조회
   */
  async getLangKeys(params: GetLangKeysParams): Promise<LangKey[]> {
    try {
      logger.info("다국어 키 목록 조회 시작", { params });

      const whereConditions: any = {};

      // 회사 코드 필터
      if (params.companyCode) {
        whereConditions.company_code = params.companyCode;
      }

      // 메뉴 코드 필터
      if (params.menuCode) {
        whereConditions.menu_name = params.menuCode;
      }

      // 검색 조건
      if (params.searchText) {
        whereConditions.OR = [
          { lang_key: { contains: params.searchText, mode: "insensitive" } },
          { description: { contains: params.searchText, mode: "insensitive" } },
          { menu_name: { contains: params.searchText, mode: "insensitive" } },
        ];
      }

      const langKeys = await prisma.multi_lang_key_master.findMany({
        where: whereConditions,
        orderBy: [
          { company_code: "asc" },
          { menu_name: "asc" },
          { lang_key: "asc" },
        ],
        select: {
          key_id: true,
          company_code: true,
          menu_name: true,
          lang_key: true,
          description: true,
          is_active: true,
          created_date: true,
          created_by: true,
          updated_date: true,
          updated_by: true,
        },
      });

      const mappedKeys: LangKey[] = langKeys.map((key) => ({
        keyId: key.key_id,
        companyCode: key.company_code,
        menuName: key.menu_name || undefined,
        langKey: key.lang_key,
        description: key.description || undefined,
        isActive: key.is_active || "Y",
        createdDate: key.created_date || undefined,
        createdBy: key.created_by || undefined,
        updatedDate: key.updated_date || undefined,
        updatedBy: key.updated_by || undefined,
      }));

      logger.info(`다국어 키 목록 조회 완료: ${mappedKeys.length}개`);
      return mappedKeys;
    } catch (error) {
      logger.error("다국어 키 목록 조회 중 오류 발생:", error);
      throw new Error(
        `다국어 키 목록 조회 실패: ${error instanceof Error ? error.message : "Unknown error"}`
      );
    }
  }

  /**
   * 특정 키의 다국어 텍스트 조회
   */
  async getLangTexts(keyId: number): Promise<LangText[]> {
    try {
      logger.info("다국어 텍스트 조회 시작", { keyId });

      const langTexts = await prisma.multi_lang_text.findMany({
        where: {
          key_id: keyId,
          is_active: "Y",
        },
        orderBy: { lang_code: "asc" },
        select: {
          text_id: true,
          key_id: true,
          lang_code: true,
          lang_text: true,
          is_active: true,
          created_date: true,
          created_by: true,
          updated_date: true,
          updated_by: true,
        },
      });

      const mappedTexts: LangText[] = langTexts.map((text) => ({
        textId: text.text_id,
        keyId: text.key_id,
        langCode: text.lang_code,
        langText: text.lang_text,
        isActive: text.is_active || "Y",
        createdDate: text.created_date || undefined,
        createdBy: text.created_by || undefined,
        updatedDate: text.updated_date || undefined,
        updatedBy: text.updated_by || undefined,
      }));

      logger.info(`다국어 텍스트 조회 완료: ${mappedTexts.length}개`);
      return mappedTexts;
    } catch (error) {
      logger.error("다국어 텍스트 조회 중 오류 발생:", error);
      throw new Error(
        `다국어 텍스트 조회 실패: ${error instanceof Error ? error.message : "Unknown error"}`
      );
    }
  }

  /**
   * 다국어 키 생성
   */
  async createLangKey(keyData: CreateLangKeyRequest): Promise<number> {
    try {
      logger.info("다국어 키 생성 시작", { keyData });

      // 중복 체크
      const existingKey = await prisma.multi_lang_key_master.findFirst({
        where: {
          company_code: keyData.companyCode,
          lang_key: keyData.langKey,
        },
      });

      if (existingKey) {
        throw new Error(
          `동일한 회사에 이미 존재하는 언어키입니다: ${keyData.langKey}`
        );
      }

      // 다국어 키 생성
      const createdKey = await prisma.multi_lang_key_master.create({
        data: {
          company_code: keyData.companyCode,
          menu_name: keyData.menuName || null,
          lang_key: keyData.langKey,
          description: keyData.description || null,
          is_active: keyData.isActive || "Y",
          created_by: keyData.createdBy || "system",
          updated_by: keyData.updatedBy || "system",
        },
      });

      logger.info("다국어 키 생성 완료", {
        keyId: createdKey.key_id,
        langKey: keyData.langKey,
      });

      return createdKey.key_id;
    } catch (error) {
      logger.error("다국어 키 생성 중 오류 발생:", error);
      throw new Error(
        `다국어 키 생성 실패: ${error instanceof Error ? error.message : "Unknown error"}`
      );
    }
  }

  /**
   * 다국어 키 수정
   */
  async updateLangKey(
    keyId: number,
    keyData: UpdateLangKeyRequest
  ): Promise<void> {
    try {
      logger.info("다국어 키 수정 시작", { keyId, keyData });

      // 기존 키 확인
      const existingKey = await prisma.multi_lang_key_master.findUnique({
        where: { key_id: keyId },
      });

      if (!existingKey) {
        throw new Error(`다국어 키를 찾을 수 없습니다: ${keyId}`);
      }

      // 중복 체크 (자신을 제외하고)
      if (keyData.companyCode && keyData.langKey) {
        const duplicateKey = await prisma.multi_lang_key_master.findFirst({
          where: {
            company_code: keyData.companyCode,
            lang_key: keyData.langKey,
            key_id: { not: keyId },
          },
        });

        if (duplicateKey) {
          throw new Error(
            `동일한 회사에 이미 존재하는 언어키입니다: ${keyData.langKey}`
          );
        }
      }

      // 다국어 키 수정
      await prisma.multi_lang_key_master.update({
        where: { key_id: keyId },
        data: {
          ...(keyData.companyCode && { company_code: keyData.companyCode }),
          ...(keyData.menuName !== undefined && {
            menu_name: keyData.menuName,
          }),
          ...(keyData.langKey && { lang_key: keyData.langKey }),
          ...(keyData.description !== undefined && {
            description: keyData.description,
          }),
          updated_by: keyData.updatedBy || "system",
        },
      });

      logger.info("다국어 키 수정 완료", { keyId });
    } catch (error) {
      logger.error("다국어 키 수정 중 오류 발생:", error);
      throw new Error(
        `다국어 키 수정 실패: ${error instanceof Error ? error.message : "Unknown error"}`
      );
    }
  }

  /**
   * 다국어 키 삭제
   */
  async deleteLangKey(keyId: number): Promise<void> {
    try {
      logger.info("다국어 키 삭제 시작", { keyId });

      // 기존 키 확인
      const existingKey = await prisma.multi_lang_key_master.findUnique({
        where: { key_id: keyId },
      });

      if (!existingKey) {
        throw new Error(`다국어 키를 찾을 수 없습니다: ${keyId}`);
      }

      // 트랜잭션으로 키와 연관된 텍스트 모두 삭제
      await prisma.$transaction(async (tx) => {
        // 관련된 다국어 텍스트 삭제
        await tx.multi_lang_text.deleteMany({
          where: { key_id: keyId },
        });

        // 다국어 키 삭제
        await tx.multi_lang_key_master.delete({
          where: { key_id: keyId },
        });
      });

      logger.info("다국어 키 삭제 완료", { keyId });
    } catch (error) {
      logger.error("다국어 키 삭제 중 오류 발생:", error);
      throw new Error(
        `다국어 키 삭제 실패: ${error instanceof Error ? error.message : "Unknown error"}`
      );
    }
  }

  /**
   * 다국어 키 상태 토글
   */
  async toggleLangKey(keyId: number): Promise<string> {
    try {
      logger.info("다국어 키 상태 토글 시작", { keyId });

      // 현재 키 조회
      const currentKey = await prisma.multi_lang_key_master.findUnique({
        where: { key_id: keyId },
        select: { is_active: true },
      });

      if (!currentKey) {
        throw new Error(`다국어 키를 찾을 수 없습니다: ${keyId}`);
      }

      const newStatus = currentKey.is_active === "Y" ? "N" : "Y";

      // 상태 업데이트
      await prisma.multi_lang_key_master.update({
        where: { key_id: keyId },
        data: {
          is_active: newStatus,
          updated_by: "system",
        },
      });

      const result = newStatus === "Y" ? "활성화" : "비활성화";
      logger.info("다국어 키 상태 토글 완료", { keyId, result });

      return result;
    } catch (error) {
      logger.error("다국어 키 상태 토글 중 오류 발생:", error);
      throw new Error(
        `다국어 키 상태 토글 실패: ${error instanceof Error ? error.message : "Unknown error"}`
      );
    }
  }

  /**
   * 다국어 텍스트 저장/수정
   */
  async saveLangTexts(
    keyId: number,
    textData: SaveLangTextsRequest
  ): Promise<void> {
    try {
      logger.info("다국어 텍스트 저장 시작", {
        keyId,
        textCount: textData.texts.length,
      });

      // 기존 키 확인
      const existingKey = await prisma.multi_lang_key_master.findUnique({
        where: { key_id: keyId },
      });

      if (!existingKey) {
        throw new Error(`다국어 키를 찾을 수 없습니다: ${keyId}`);
      }

      // 트랜잭션으로 기존 텍스트 삭제 후 새로 생성
      await prisma.$transaction(async (tx) => {
        // 기존 텍스트 삭제
        await tx.multi_lang_text.deleteMany({
          where: { key_id: keyId },
        });

        // 새로운 텍스트 삽입
        if (textData.texts.length > 0) {
          await tx.multi_lang_text.createMany({
            data: textData.texts.map((text) => ({
              key_id: keyId,
              lang_code: text.langCode,
              lang_text: text.langText,
              is_active: text.isActive || "Y",
              created_by: text.createdBy || "system",
              updated_by: text.updatedBy || "system",
            })),
          });
        }
      });

      logger.info("다국어 텍스트 저장 완료", {
        keyId,
        savedCount: textData.texts.length,
      });
    } catch (error) {
      logger.error("다국어 텍스트 저장 중 오류 발생:", error);
      throw new Error(
        `다국어 텍스트 저장 실패: ${error instanceof Error ? error.message : "Unknown error"}`
      );
    }
  }

  /**
   * 사용자별 다국어 텍스트 조회
   */
  async getUserText(params: GetUserTextParams): Promise<string> {
    try {
      logger.info("사용자별 다국어 텍스트 조회 시작", { params });

      const result = await prisma.multi_lang_text.findFirst({
        where: {
          lang_code: params.userLang,
          is_active: "Y",
          multi_lang_key_master: {
            company_code: params.companyCode,
            menu_name: params.menuCode,
            lang_key: params.langKey,
            is_active: "Y",
          },
        },
        select: {
          lang_text: true,
        },
      });

      if (!result) {
        logger.warn("사용자별 다국어 텍스트를 찾을 수 없음", { params });
        return params.langKey; // 기본값으로 키 반환
      }

      logger.info("사용자별 다국어 텍스트 조회 완료", {
        params,
        langText: result.lang_text,
      });

      return result.lang_text;
    } catch (error) {
      logger.error("사용자별 다국어 텍스트 조회 중 오류 발생:", error);
      throw new Error(
        `사용자별 다국어 텍스트 조회 실패: ${error instanceof Error ? error.message : "Unknown error"}`
      );
    }
  }

  /**
   * 특정 키의 다국어 텍스트 조회
   */
  async getLangText(
    companyCode: string,
    langKey: string,
    langCode: string
  ): Promise<string> {
    try {
      logger.info("특정 키의 다국어 텍스트 조회 시작", {
        companyCode,
        langKey,
        langCode,
      });

      const result = await prisma.multi_lang_text.findFirst({
        where: {
          lang_code: langCode,
          is_active: "Y",
          multi_lang_key_master: {
            company_code: companyCode,
            lang_key: langKey,
            is_active: "Y",
          },
        },
        select: {
          lang_text: true,
        },
      });

      if (!result) {
        logger.warn("특정 키의 다국어 텍스트를 찾을 수 없음", {
          companyCode,
          langKey,
          langCode,
        });
        return langKey; // 기본값으로 키 반환
      }

      logger.info("특정 키의 다국어 텍스트 조회 완료", {
        companyCode,
        langKey,
        langCode,
        langText: result.lang_text,
      });

      return result.lang_text;
    } catch (error) {
      logger.error("특정 키의 다국어 텍스트 조회 중 오류 발생:", error);
      throw new Error(
        `특정 키의 다국어 텍스트 조회 실패: ${error instanceof Error ? error.message : "Unknown error"}`
      );
    }
  }

  /**
   * 배치 번역 조회
   */
  async getBatchTranslations(
    params: BatchTranslationRequest
  ): Promise<Record<string, string>> {
    try {
      logger.info("배치 번역 조회 시작", {
        companyCode: params.companyCode,
        menuCode: params.menuCode,
        userLang: params.userLang,
        keyCount: params.langKeys.length,
      });

      if (params.langKeys.length === 0) {
        return {};
      }

      // 모든 키에 대한 번역 조회
      const translations = await prisma.multi_lang_text.findMany({
        where: {
          lang_code: params.userLang,
          is_active: "Y",
          multi_lang_key_master: {
            lang_key: { in: params.langKeys },
            company_code: { in: [params.companyCode, "*"] },
            is_active: "Y",
          },
        },
        select: {
          lang_text: true,
          multi_lang_key_master: {
            select: {
              lang_key: true,
              company_code: true,
            },
          },
        },
        orderBy: {
          multi_lang_key_master: {
            company_code: "asc", // 회사별 우선, '*' 는 기본값
          },
        },
      });

      const result: Record<string, string> = {};

      // 기본값으로 모든 키 설정
      params.langKeys.forEach((key) => {
        result[key] = key;
      });

      // 실제 번역으로 덮어쓰기 (회사별 우선)
      translations.forEach((translation) => {
        const langKey = translation.multi_lang_key_master.lang_key;
        if (params.langKeys.includes(langKey)) {
          result[langKey] = translation.lang_text;
        }
      });

      logger.info("배치 번역 조회 완료", {
        totalKeys: params.langKeys.length,
        foundTranslations: translations.length,
        resultKeys: Object.keys(result).length,
      });

      return result;
    } catch (error) {
      logger.error("배치 번역 조회 중 오류 발생:", error);
      throw new Error(
        `배치 번역 조회 실패: ${error instanceof Error ? error.message : "Unknown error"}`
      );
    }
  }

  /**
   * 언어 삭제
   */
  async deleteLanguage(langCode: string): Promise<void> {
    try {
      logger.info("언어 삭제 시작", { langCode });

      // 기존 언어 확인
      const existingLanguage = await prisma.language_master.findUnique({
        where: { lang_code: langCode },
      });

      if (!existingLanguage) {
        throw new Error(`언어를 찾을 수 없습니다: ${langCode}`);
      }

      // 트랜잭션으로 언어와 관련 텍스트 삭제
      await prisma.$transaction(async (tx) => {
        // 해당 언어의 다국어 텍스트 삭제
        const deleteResult = await tx.multi_lang_text.deleteMany({
          where: { lang_code: langCode },
        });

        logger.info(`삭제된 다국어 텍스트 수: ${deleteResult.count}`, {
          langCode,
        });

        // 언어 마스터 삭제
        await tx.language_master.delete({
          where: { lang_code: langCode },
        });
      });

      logger.info("언어 삭제 완료", { langCode });
    } catch (error) {
      logger.error("언어 삭제 중 오류 발생:", error);
      throw new Error(
        `언어 삭제 실패: ${error instanceof Error ? error.message : "Unknown error"}`
      );
    }
  }
}