import { Response } from "express";
import { AuthenticatedRequest } from "../types/auth";
import { query, queryOne } from "../database/db";

// ============================================================
// 대결 위임 설정 (Approval Proxy Settings) CRUD
// ============================================================

export class ApprovalProxyController {
  // 대결 위임 목록 조회 (user_info JOIN으로 이름/부서 포함)
  static async getProxySettings(req: AuthenticatedRequest, res: Response) {
    try {
      const companyCode = req.user?.companyCode;
      if (!companyCode) {
        return res.status(401).json({ success: false, message: "인증 정보가 없습니다." });
      }

      const rows = await query<any>(
        `SELECT ps.*,
                u1.user_name AS original_user_name, u1.dept_name AS original_dept_name,
                u2.user_name AS proxy_user_name, u2.dept_name AS proxy_dept_name
         FROM approval_proxy_settings ps
         LEFT JOIN user_info u1 ON ps.original_user_id = u1.user_id AND ps.company_code = u1.company_code
         LEFT JOIN user_info u2 ON ps.proxy_user_id = u2.user_id AND ps.company_code = u2.company_code
         WHERE ps.company_code = $1
         ORDER BY ps.created_at DESC`,
        [companyCode]
      );

      return res.json({ success: true, data: rows });
    } catch (error) {
      console.error("대결 위임 목록 조회 오류:", error);
      return res.status(500).json({
        success: false,
        message: "대결 위임 목록 조회 중 오류가 발생했습니다.",
        error: error instanceof Error ? error.message : "알 수 없는 오류",
      });
    }
  }

  // 대결 위임 생성 (기간 중복 체크 포함)
  static async createProxySetting(req: AuthenticatedRequest, res: Response) {
    try {
      const companyCode = req.user?.companyCode;
      if (!companyCode) {
        return res.status(401).json({ success: false, message: "인증 정보가 없습니다." });
      }

      const { original_user_id, proxy_user_id, start_date, end_date, reason, is_active = "Y" } = req.body;

      if (!original_user_id || !proxy_user_id) {
        return res.status(400).json({ success: false, message: "위임자와 대결자는 필수입니다." });
      }
      if (!start_date || !end_date) {
        return res.status(400).json({ success: false, message: "시작일과 종료일은 필수입니다." });
      }
      if (original_user_id === proxy_user_id) {
        return res.status(400).json({ success: false, message: "위임자와 대결자가 동일할 수 없습니다." });
      }

      // 같은 기간 중복 체크 (daterange 오버랩)
      const overlap = await queryOne<any>(
        `SELECT COUNT(*) AS cnt FROM approval_proxy_settings
         WHERE original_user_id = $1 AND is_active = 'Y'
         AND daterange(start_date, end_date, '[]') && daterange($2::date, $3::date, '[]')
         AND company_code = $4`,
        [original_user_id, start_date, end_date, companyCode]
      );

      if (overlap && parseInt(overlap.cnt) > 0) {
        return res.status(400).json({ success: false, message: "해당 기간에 이미 대결 설정이 존재합니다." });
      }

      const [row] = await query<any>(
        `INSERT INTO approval_proxy_settings
         (original_user_id, proxy_user_id, start_date, end_date, reason, is_active, company_code)
         VALUES ($1, $2, $3, $4, $5, $6, $7)
         RETURNING *`,
        [original_user_id, proxy_user_id, start_date, end_date, reason || null, is_active, companyCode]
      );

      return res.status(201).json({ success: true, data: row, message: "대결 위임이 생성되었습니다." });
    } catch (error) {
      console.error("대결 위임 생성 오류:", error);
      return res.status(500).json({
        success: false,
        message: "대결 위임 생성 중 오류가 발생했습니다.",
        error: error instanceof Error ? error.message : "알 수 없는 오류",
      });
    }
  }

  // 대결 위임 수정
  static async updateProxySetting(req: AuthenticatedRequest, res: Response) {
    try {
      const companyCode = req.user?.companyCode;
      if (!companyCode) {
        return res.status(401).json({ success: false, message: "인증 정보가 없습니다." });
      }

      const { id } = req.params;
      const existing = await queryOne<any>(
        "SELECT id FROM approval_proxy_settings WHERE id = $1 AND company_code = $2",
        [id, companyCode]
      );

      if (!existing) {
        return res.status(404).json({ success: false, message: "대결 위임 설정을 찾을 수 없습니다." });
      }

      const { proxy_user_id, start_date, end_date, reason, is_active } = req.body;

      const fields: string[] = [];
      const params: any[] = [];
      let idx = 1;

      if (proxy_user_id !== undefined) { fields.push(`proxy_user_id = $${idx++}`); params.push(proxy_user_id); }
      if (start_date !== undefined) { fields.push(`start_date = $${idx++}`); params.push(start_date); }
      if (end_date !== undefined) { fields.push(`end_date = $${idx++}`); params.push(end_date); }
      if (reason !== undefined) { fields.push(`reason = $${idx++}`); params.push(reason); }
      if (is_active !== undefined) { fields.push(`is_active = $${idx++}`); params.push(is_active); }

      if (fields.length === 0) {
        return res.status(400).json({ success: false, message: "수정할 필드가 없습니다." });
      }

      fields.push(`updated_at = NOW()`);
      params.push(id, companyCode);

      const [row] = await query<any>(
        `UPDATE approval_proxy_settings SET ${fields.join(", ")}
         WHERE id = $${idx++} AND company_code = $${idx++}
         RETURNING *`,
        params
      );

      return res.json({ success: true, data: row, message: "대결 위임이 수정되었습니다." });
    } catch (error) {
      console.error("대결 위임 수정 오류:", error);
      return res.status(500).json({
        success: false,
        message: "대결 위임 수정 중 오류가 발생했습니다.",
        error: error instanceof Error ? error.message : "알 수 없는 오류",
      });
    }
  }

  // 대결 위임 삭제
  static async deleteProxySetting(req: AuthenticatedRequest, res: Response) {
    try {
      const companyCode = req.user?.companyCode;
      if (!companyCode) {
        return res.status(401).json({ success: false, message: "인증 정보가 없습니다." });
      }

      const { id } = req.params;

      const result = await query<any>(
        "DELETE FROM approval_proxy_settings WHERE id = $1 AND company_code = $2 RETURNING id",
        [id, companyCode]
      );

      if (result.length === 0) {
        return res.status(404).json({ success: false, message: "대결 위임 설정을 찾을 수 없습니다." });
      }

      return res.json({ success: true, message: "대결 위임이 삭제되었습니다." });
    } catch (error) {
      console.error("대결 위임 삭제 오류:", error);
      return res.status(500).json({
        success: false,
        message: "대결 위임 삭제 중 오류가 발생했습니다.",
        error: error instanceof Error ? error.message : "알 수 없는 오류",
      });
    }
  }

  // 특정 사용자의 현재 활성 대결자 조회
  static async checkActiveProxy(req: AuthenticatedRequest, res: Response) {
    try {
      const companyCode = req.user?.companyCode;
      if (!companyCode) {
        return res.status(401).json({ success: false, message: "인증 정보가 없습니다." });
      }

      const { userId } = req.params;

      if (!userId) {
        return res.status(400).json({ success: false, message: "userId 파라미터는 필수입니다." });
      }

      const rows = await query<any>(
        `SELECT ps.*, u.user_name AS proxy_user_name
         FROM approval_proxy_settings ps
         LEFT JOIN user_info u ON ps.proxy_user_id = u.user_id AND ps.company_code = u.company_code
         WHERE ps.original_user_id = $1 AND ps.is_active = 'Y'
         AND ps.start_date <= CURRENT_DATE AND ps.end_date >= CURRENT_DATE
         AND ps.company_code = $2`,
        [userId, companyCode]
      );

      return res.json({ success: true, data: rows });
    } catch (error) {
      console.error("활성 대결자 조회 오류:", error);
      return res.status(500).json({
        success: false,
        message: "활성 대결자 조회 중 오류가 발생했습니다.",
        error: error instanceof Error ? error.message : "알 수 없는 오류",
      });
    }
  }
}
