import { Response } from "express";
import { Request } from "express";
import { AuthenticatedRequest } from "../types/auth";
import { AdminService } from "../services/adminService";
import { logger } from "../utils/logger";
import { ApiResponse } from "../types/auth";

/**
 * 관리자 메뉴 목록 조회
 */
export async function getAdminMenus(
  req: AuthenticatedRequest,
  res: Response
): Promise<void> {
  try {
    logger.info("=== 관리자 메뉴 목록 조회 시작 ===");

    // 현재 로그인한 사용자의 회사 코드와 로케일 가져오기
    const userCompanyCode = req.user?.companyCode || "ILSHIN";
    const userLang = (req.query.userLang as string) || "ko";

    logger.info(`사용자 회사 코드: ${userCompanyCode}`);
    logger.info(`사용자 로케일: ${userLang}`);

    const paramMap = {
      userCompanyCode,
      userLang,
      SYSTEM_NAME: "PLM",
    };

    const menuList = await AdminService.getAdminMenuList(paramMap);

    logger.info(`관리자 메뉴 조회 결과: ${menuList.length}개`);
    if (menuList.length > 0) {
      logger.info("첫 번째 메뉴:", menuList[0]);
    }

    const response: ApiResponse<any[]> = {
      success: true,
      message: "관리자 메뉴 목록 조회 성공",
      data: menuList,
    };

    res.status(200).json(response);
  } catch (error) {
    logger.error("관리자 메뉴 목록 조회 중 오류 발생:", error);

    const response: ApiResponse<null> = {
      success: false,
      message: "관리자 메뉴 목록 조회 중 오류가 발생했습니다.",
      error: {
        code: "ADMIN_MENU_LIST_ERROR",
        details: error instanceof Error ? error.message : "Unknown error",
      },
    };

    res.status(500).json(response);
  }
}

/**
 * 사용자 메뉴 목록 조회
 */
export async function getUserMenus(
  req: AuthenticatedRequest,
  res: Response
): Promise<void> {
  try {
    logger.info("=== 사용자 메뉴 목록 조회 시작 ===");

    // 현재 로그인한 사용자의 회사 코드와 로케일 가져오기
    const userCompanyCode = req.user?.companyCode || "ILSHIN";
    const userLang = (req.query.userLang as string) || "ko";

    logger.info(`사용자 회사 코드: ${userCompanyCode}`);
    logger.info(`사용자 로케일: ${userLang}`);

    const paramMap = {
      userCompanyCode,
      userLang,
      SYSTEM_NAME: "PLM",
    };

    const menuList = await AdminService.getUserMenuList(paramMap);

    logger.info(`사용자 메뉴 조회 결과: ${menuList.length}개`);
    if (menuList.length > 0) {
      logger.info("첫 번째 메뉴:", menuList[0]);
    }

    const response: ApiResponse<any[]> = {
      success: true,
      message: "사용자 메뉴 목록 조회 성공",
      data: menuList,
    };

    res.status(200).json(response);
  } catch (error) {
    logger.error("사용자 메뉴 목록 조회 중 오류 발생:", error);

    const response: ApiResponse<null> = {
      success: false,
      message: "사용자 메뉴 목록 조회 중 오류가 발생했습니다.",
      error: {
        code: "USER_MENU_LIST_ERROR",
        details: error instanceof Error ? error.message : "Unknown error",
      },
    };

    res.status(500).json(response);
  }
}

/**
 * 메뉴 정보 조회
 */
export async function getMenuInfo(
  req: AuthenticatedRequest,
  res: Response
): Promise<void> {
  try {
    const { menuId } = req.params;
    logger.info(`=== 메뉴 정보 조회 시작 - menuId: ${menuId} ===`);

    const menuInfo = await AdminService.getMenuInfo(menuId);

    if (!menuInfo) {
      const response: ApiResponse<null> = {
        success: false,
        message: "메뉴를 찾을 수 없습니다.",
        error: {
          code: "MENU_NOT_FOUND",
          details: `Menu ID: ${menuId}`,
        },
      };
      res.status(404).json(response);
      return;
    }

    const response: ApiResponse<any> = {
      success: true,
      message: "메뉴 정보 조회 성공",
      data: menuInfo,
    };

    res.status(200).json(response);
  } catch (error) {
    logger.error("메뉴 정보 조회 중 오류 발생:", error);

    const response: ApiResponse<null> = {
      success: false,
      message: "메뉴 정보 조회 중 오류가 발생했습니다.",
      error: {
        code: "MENU_INFO_ERROR",
        details: error instanceof Error ? error.message : "Unknown error",
      },
    };

    res.status(500).json(response);
  }
}

/**
 * GET /api/admin/users
 * 사용자 목록 조회 API
 * 기존 Java AdminController.getUserList() 포팅
 */
export const getUserList = async (req: AuthenticatedRequest, res: Response) => {
  try {
    logger.info("사용자 목록 조회 요청", {
      query: req.query,
      user: req.user,
    });

    // 임시 더미 데이터 반환 (실제로는 데이터베이스에서 조회)
    const { page = 1, countPerPage = 20 } = req.query;

    const dummyUsers = [
      {
        userId: "plm_admin",
        userName: "관리자",
        deptName: "IT팀",
        companyCode: "ILSHIN",
        userType: "admin",
        email: "admin@ilshin.com",
        status: "active",
        regDate: "2024-01-15",
      },
      {
        userId: "user001",
        userName: "홍길동",
        deptName: "영업팀",
        companyCode: "ILSHIN",
        userType: "user",
        email: "hong@ilshin.com",
        status: "active",
        regDate: "2024-01-16",
      },
      {
        userId: "user002",
        userName: "김철수",
        deptName: "개발팀",
        companyCode: "ILSHIN",
        userType: "user",
        email: "kim@ilshin.com",
        status: "inactive",
        regDate: "2024-01-17",
      },
    ];

    // 페이징 처리
    const startIndex = (Number(page) - 1) * Number(countPerPage);
    const endIndex = startIndex + Number(countPerPage);
    const paginatedUsers = dummyUsers.slice(startIndex, endIndex);

    const response = {
      success: true,
      data: {
        users: paginatedUsers,
        pagination: {
          currentPage: Number(page),
          countPerPage: Number(countPerPage),
          totalCount: dummyUsers.length,
          totalPages: Math.ceil(dummyUsers.length / Number(countPerPage)),
        },
      },
      message: "사용자 목록 조회 성공",
    };

    logger.info("사용자 목록 조회 성공", {
      totalCount: dummyUsers.length,
      returnedCount: paginatedUsers.length,
    });

    res.status(200).json(response);
  } catch (error) {
    logger.error("사용자 목록 조회 실패", { error });
    res.status(500).json({
      success: false,
      message: "사용자 목록 조회 중 오류가 발생했습니다.",
      error: error instanceof Error ? error.message : "Unknown error",
    });
  }
};

/**
 * GET /api/admin/user-locale
 * 사용자 로케일 조회 API
 */
export const getUserLocale = async (
  req: AuthenticatedRequest,
  res: Response
) => {
  try {
    logger.info("사용자 로케일 조회 요청", {
      query: req.query,
      user: req.user,
    });

    // 임시 더미 데이터 반환 (실제로는 데이터베이스에서 조회)
    const userLocale = "ko"; // 기본값

    const response = {
      success: true,
      data: userLocale,
      message: "사용자 로케일 조회 성공",
    };

    logger.info("사용자 로케일 조회 성공", {
      userLocale,
    });

    res.status(200).json(response);
  } catch (error) {
    logger.error("사용자 로케일 조회 실패", { error });
    res.status(500).json({
      success: false,
      message: "사용자 로케일 조회 중 오류가 발생했습니다.",
      error: error instanceof Error ? error.message : "Unknown error",
    });
  }
};

/**
 * GET /api/admin/companies
 * 회사 목록 조회 API
 */
export const getCompanyList = async (
  req: AuthenticatedRequest,
  res: Response
) => {
  try {
    logger.info("회사 목록 조회 요청", {
      query: req.query,
      user: req.user,
    });

    // 임시 더미 데이터 반환 (실제로는 데이터베이스에서 조회)
    const dummyCompanies = [
      {
        company_code: "ILSHIN",
        company_name: "일신제강",
      },
      {
        company_code: "HUTECH",
        company_name: "후테크",
      },
      {
        company_code: "DAIN",
        company_name: "다인",
      },
    ];

    const response = {
      success: true,
      data: dummyCompanies,
      message: "회사 목록 조회 성공",
    };

    logger.info("회사 목록 조회 성공", {
      totalCount: dummyCompanies.length,
    });

    res.status(200).json(response);
  } catch (error) {
    logger.error("회사 목록 조회 실패", { error });
    res.status(500).json({
      success: false,
      message: "회사 목록 조회 중 오류가 발생했습니다.",
      error: error instanceof Error ? error.message : "Unknown error",
    });
  }
};

/**
 * 다국어 언어 목록 조회 (더미 데이터)
 */
export async function getLanguageList(
  req: AuthenticatedRequest,
  res: Response
): Promise<void> {
  try {
    logger.info("다국어 언어 목록 조회 요청");

    // 더미 데이터 반환
    const languages = [
      {
        langCode: "KR",
        langName: "한국어",
        langNative: "한국어",
        isActive: "Y",
      },
      {
        langCode: "EN",
        langName: "English",
        langNative: "English",
        isActive: "Y",
      },
      {
        langCode: "JP",
        langName: "日本語",
        langNative: "日本語",
        isActive: "Y",
      },
      { langCode: "CN", langName: "中文", langNative: "中文", isActive: "Y" },
    ];

    const response: ApiResponse<any[]> = {
      success: true,
      message: "언어 목록 조회 성공",
      data: languages,
    };

    res.status(200).json(response);
  } catch (error) {
    logger.error("언어 목록 조회 실패:", error);
    res.status(500).json({
      success: false,
      message: "언어 목록 조회 중 오류가 발생했습니다.",
      error: error instanceof Error ? error.message : "Unknown error",
    });
  }
}

/**
 * 다국어 키 목록 조회 (더미 데이터)
 */
export async function getLangKeyList(
  req: AuthenticatedRequest,
  res: Response
): Promise<void> {
  try {
    logger.info("다국어 키 목록 조회 요청");

    // 더미 데이터 반환
    const langKeys = [
      {
        keyId: 1,
        companyCode: "ILSHIN",
        menuName: "사용자 관리",
        langKey: "user.management.title",
        description: "사용자 관리 페이지 제목",
        isActive: "Y",
      },
      {
        keyId: 2,
        companyCode: "ILSHIN",
        menuName: "메뉴 관리",
        langKey: "menu.management.title",
        description: "메뉴 관리 페이지 제목",
        isActive: "Y",
      },
      {
        keyId: 3,
        companyCode: "HUTECH",
        menuName: "대시보드",
        langKey: "dashboard.title",
        description: "대시보드 페이지 제목",
        isActive: "Y",
      },
    ];

    const response: ApiResponse<any[]> = {
      success: true,
      message: "다국어 키 목록 조회 성공",
      data: langKeys,
    };

    res.status(200).json(response);
  } catch (error) {
    logger.error("다국어 키 목록 조회 실패:", error);
    res.status(500).json({
      success: false,
      message: "다국어 키 목록 조회 중 오류가 발생했습니다.",
      error: error instanceof Error ? error.message : "Unknown error",
    });
  }
}

/**
 * 다국어 텍스트 목록 조회 (더미 데이터)
 */
export async function getLangTextList(
  req: AuthenticatedRequest,
  res: Response
): Promise<void> {
  try {
    const { keyId } = req.params;
    logger.info(`다국어 텍스트 목록 조회 요청: keyId = ${keyId}`);

    // 더미 데이터 반환
    const langTexts = [
      {
        textId: 1,
        keyId: parseInt(keyId),
        langCode: "KR",
        langText: "사용자 관리",
        isActive: "Y",
      },
      {
        textId: 2,
        keyId: parseInt(keyId),
        langCode: "EN",
        langText: "User Management",
        isActive: "Y",
      },
      {
        textId: 3,
        keyId: parseInt(keyId),
        langCode: "JP",
        langText: "ユーザー管理",
        isActive: "Y",
      },
    ];

    const response: ApiResponse<any[]> = {
      success: true,
      message: "다국어 텍스트 목록 조회 성공",
      data: langTexts,
    };

    res.status(200).json(response);
  } catch (error) {
    logger.error("다국어 텍스트 목록 조회 실패:", error);
    res.status(500).json({
      success: false,
      message: "다국어 텍스트 목록 조회 중 오류가 발생했습니다.",
      error: error instanceof Error ? error.message : "Unknown error",
    });
  }
}

/**
 * 다국어 텍스트 저장 (더미 데이터)
 */
export async function saveLangTexts(
  req: AuthenticatedRequest,
  res: Response
): Promise<void> {
  try {
    const { keyId } = req.params;
    const textData = req.body;
    logger.info(`다국어 텍스트 저장 요청: keyId = ${keyId}`, { textData });

    // 더미 응답
    const response: ApiResponse<any> = {
      success: true,
      message: "다국어 텍스트 저장 성공",
      data: { savedCount: textData.length },
    };

    res.status(200).json(response);
  } catch (error) {
    logger.error("다국어 텍스트 저장 실패:", error);
    res.status(500).json({
      success: false,
      message: "다국어 텍스트 저장 중 오류가 발생했습니다.",
      error: error instanceof Error ? error.message : "Unknown error",
    });
  }
}

/**
 * 다국어 키 저장 (더미 데이터)
 */
export async function saveLangKey(
  req: AuthenticatedRequest,
  res: Response
): Promise<void> {
  try {
    const keyData = req.body;
    logger.info("다국어 키 저장 요청", { keyData });

    // 더미 응답
    const response: ApiResponse<any> = {
      success: true,
      message: "다국어 키 저장 성공",
      data: { keyId: Math.floor(Math.random() * 1000) + 1 },
    };

    res.status(200).json(response);
  } catch (error) {
    logger.error("다국어 키 저장 실패:", error);
    res.status(500).json({
      success: false,
      message: "다국어 키 저장 중 오류가 발생했습니다.",
      error: error instanceof Error ? error.message : "Unknown error",
    });
  }
}

/**
 * 다국어 키 수정 (더미 데이터)
 */
export async function updateLangKey(
  req: AuthenticatedRequest,
  res: Response
): Promise<void> {
  try {
    const { keyId } = req.params;
    const keyData = req.body;
    logger.info(`다국어 키 수정 요청: keyId = ${keyId}`, { keyData });

    // 더미 응답
    const response: ApiResponse<any> = {
      success: true,
      message: "다국어 키 수정 성공",
      data: { keyId: parseInt(keyId) },
    };

    res.status(200).json(response);
  } catch (error) {
    logger.error("다국어 키 수정 실패:", error);
    res.status(500).json({
      success: false,
      message: "다국어 키 수정 중 오류가 발생했습니다.",
      error: error instanceof Error ? error.message : "Unknown error",
    });
  }
}

/**
 * 다국어 키 삭제 (더미 데이터)
 */
export async function deleteLangKey(
  req: AuthenticatedRequest,
  res: Response
): Promise<void> {
  try {
    const { keyId } = req.params;
    logger.info(`다국어 키 삭제 요청: keyId = ${keyId}`);

    // 더미 응답
    const response: ApiResponse<any> = {
      success: true,
      message: "다국어 키 삭제 성공",
      data: { deletedKeyId: parseInt(keyId) },
    };

    res.status(200).json(response);
  } catch (error) {
    logger.error("다국어 키 삭제 실패:", error);
    res.status(500).json({
      success: false,
      message: "다국어 키 삭제 중 오류가 발생했습니다.",
      error: error instanceof Error ? error.message : "Unknown error",
    });
  }
}

/**
 * 다국어 키 상태 토글 (더미 데이터)
 */
export async function toggleLangKeyStatus(
  req: AuthenticatedRequest,
  res: Response
): Promise<void> {
  try {
    const { keyId } = req.params;
    logger.info(`다국어 키 상태 토글 요청: keyId = ${keyId}`);

    // 더미 응답
    const response: ApiResponse<any> = {
      success: true,
      message: "다국어 키 상태 토글 성공",
      data: "활성화",
    };

    res.status(200).json(response);
  } catch (error) {
    logger.error("다국어 키 상태 토글 실패:", error);
    res.status(500).json({
      success: false,
      message: "다국어 키 상태 토글 중 오류가 발생했습니다.",
      error: error instanceof Error ? error.message : "Unknown error",
    });
  }
}

/**
 * 언어 저장 (더미 데이터)
 */
export async function saveLanguage(
  req: AuthenticatedRequest,
  res: Response
): Promise<void> {
  try {
    const langData = req.body;
    logger.info("언어 저장 요청", { langData });

    // 더미 응답
    const response: ApiResponse<any> = {
      success: true,
      message: "언어 저장 성공",
      data: { langCode: langData.langCode },
    };

    res.status(200).json(response);
  } catch (error) {
    logger.error("언어 저장 실패:", error);
    res.status(500).json({
      success: false,
      message: "언어 저장 중 오류가 발생했습니다.",
      error: error instanceof Error ? error.message : "Unknown error",
    });
  }
}

/**
 * 언어 수정 (더미 데이터)
 */
export async function updateLanguage(
  req: AuthenticatedRequest,
  res: Response
): Promise<void> {
  try {
    const { langCode } = req.params;
    const langData = req.body;
    logger.info(`언어 수정 요청: langCode = ${langCode}`, { langData });

    // 더미 응답
    const response: ApiResponse<any> = {
      success: true,
      message: "언어 수정 성공",
      data: { langCode },
    };

    res.status(200).json(response);
  } catch (error) {
    logger.error("언어 수정 실패:", error);
    res.status(500).json({
      success: false,
      message: "언어 수정 중 오류가 발생했습니다.",
      error: error instanceof Error ? error.message : "Unknown error",
    });
  }
}

/**
 * 언어 상태 토글 (더미 데이터)
 */
export async function toggleLanguageStatus(
  req: AuthenticatedRequest,
  res: Response
): Promise<void> {
  try {
    const { langCode } = req.params;
    logger.info(`언어 상태 토글 요청: langCode = ${langCode}`);

    // 더미 응답
    const response: ApiResponse<any> = {
      success: true,
      message: "언어 상태 토글 성공",
      data: "활성화",
    };

    res.status(200).json(response);
  } catch (error) {
    logger.error("언어 상태 토글 실패:", error);
    res.status(500).json({
      success: false,
      message: "언어 상태 토글 중 오류가 발생했습니다.",
      error: error instanceof Error ? error.message : "Unknown error",
    });
  }
}