path: root/lib/users/department-domain/service.ts

"use server";

import { revalidatePath, revalidateTag } from "next/cache";
import { unstable_cache, unstable_noStore } from "next/cache";
import db from "@/db/db";
import { 
  departmentDomainAssignments,
  departmentDomainAssignmentHistory
} from "@/db/schema/departmentDomainAssignments";
import { users } from "@/db/schema/users";
import { and, eq, inArray, desc } from "drizzle-orm";
import { getServerSession } from "next-auth/next";
import { authOptions } from "@/app/api/auth/[...nextauth]/route";
import { getErrorMessage } from "@/lib/handle-error";
import { getCurrentCompanyCode } from "@/lib/users/knox-service";

// 도메인 타입
export type UserDomain = "pending" | "evcp" | "procurement" | "sales" | "engineering" | "partners";

// 부서별 도메인 할당 정보 조회
export async function getDepartmentDomainAssignments() {
  return unstable_cache(
    async () => {
      try {
        const assignments = await db
          .select({
            id: departmentDomainAssignments.id,
            companyCode: departmentDomainAssignments.companyCode,
            departmentCode: departmentDomainAssignments.departmentCode,
            departmentName: departmentDomainAssignments.departmentName,
            assignedDomain: departmentDomainAssignments.assignedDomain,
            isActive: departmentDomainAssignments.isActive,
            description: departmentDomainAssignments.description,
            createdAt: departmentDomainAssignments.createdAt,
            updatedAt: departmentDomainAssignments.updatedAt,
          })
          .from(departmentDomainAssignments)
          .where(eq(departmentDomainAssignments.isActive, true))
          .orderBy(
            desc(departmentDomainAssignments.updatedAt)
          );

        return assignments;
      } catch (error) {
        console.error("부서별 도메인 할당 정보 조회 실패:", error);
        return [];
      }
    },
    ["department-domain-assignments"],
    {
      revalidate: 3600, // 1시간 캐시
      tags: ["department-domain-assignments"],
    }
  )();
}

// 특정 부서들의 도메인 할당 정보 조회
export async function getDepartmentDomainAssignmentsByDepartments(departmentCodes: string[]) {
  return unstable_cache(
    async () => {
      try {
        if (departmentCodes.length === 0) return [];

        const assignments = await db
          .select()
          .from(departmentDomainAssignments)
          .where(
            and(
              inArray(departmentDomainAssignments.departmentCode, departmentCodes),
              eq(departmentDomainAssignments.isActive, true)
            )
          );

        return assignments;
      } catch (error) {
        console.error("부서별 도메인 할당 정보 조회 실패:", error);
        return [];
      }
    },
    [`department-assignments-${departmentCodes.sort().join(',')}`],
    {
      revalidate: 3600,
      tags: ["department-domain-assignments"],
    }
  )();
}

// 부서별 도메인 할당
export async function assignDomainToDepartments(params: {
  departmentCodes: string[];
  domain: UserDomain;
  description?: string;
  departmentNames?: Record<string, string>; // departmentCode -> departmentName 매핑
}) {
  unstable_noStore();
  
  try {
    // 세션 확인
    const session = await getServerSession(authOptions);
    if (!session?.user?.id) {
      return {
        success: false,
        message: "인증이 필요합니다.",
      };
    }

    const { departmentCodes, domain, description, departmentNames = {} } = params;
    const userId = parseInt(session.user.id);

    if (!departmentCodes.length || !domain) {
      return {
        success: false,
        message: "부서 코드와 도메인이 필요합니다.",
      };
    }

    // 현재 회사 코드 가져오기
    const companyCode = await getCurrentCompanyCode();

    await db.transaction(async (tx) => {
      // 기존 할당 정보를 비활성화 (soft delete)
      const existingAssignments = await tx
        .select()
        .from(departmentDomainAssignments)
        .where(
          and(
            inArray(departmentDomainAssignments.departmentCode, departmentCodes),
            eq(departmentDomainAssignments.isActive, true)
          )
        );

      // 기존 할당이 있으면 비활성화하고 히스토리 기록
      for (const existing of existingAssignments) {
        // 히스토리 기록
        await tx.insert(departmentDomainAssignmentHistory).values({
          assignmentId: existing.id,
          action: "deactivated",
          previousValues: JSON.stringify({
            assignedDomain: existing.assignedDomain,
            isActive: true,
            description: existing.description,
          }),
          newValues: JSON.stringify({
            isActive: false,
          }),
          changedBy: userId,
          changeReason: `새로운 도메인 할당으로 인한 기존 할당 비활성화: ${domain}`,
        });

        // 기존 할당 비활성화
        await tx
          .update(departmentDomainAssignments)
          .set({
            isActive: false,
            updatedBy: userId,
            updatedAt: new Date(),
          })
          .where(eq(departmentDomainAssignments.id, existing.id));
      }

      // 새로운 할당 생성
      const newAssignments = departmentCodes.map(departmentCode => {
        return {
          companyCode,
          departmentCode,
          departmentName: departmentNames[departmentCode] || departmentCode,
          assignedDomain: domain,
          description,
          isActive: true,
          createdBy: userId,
          updatedBy: userId,
        };
      });

      const insertedAssignments = await tx
        .insert(departmentDomainAssignments)
        .values(newAssignments)
        .returning();

      // 신규 생성 히스토리 기록
      for (let i = 0; i < insertedAssignments.length; i++) {
        const assignment = insertedAssignments[i];
        await tx.insert(departmentDomainAssignmentHistory).values({
          assignmentId: assignment.id,
          action: "created",
          newValues: JSON.stringify({
            companyCode: assignment.companyCode,
            departmentCode: assignment.departmentCode,
            assignedDomain: assignment.assignedDomain,
            description: assignment.description,
          }),
          changedBy: userId,
          changeReason: description || "부서별 도메인 할당",
        });
      }
    });

    // 캐시 무효화
    revalidateTag("department-domain-assignments");
    revalidatePath("/evcp/menu-access-dept");

    return {
      success: true,
      message: `${departmentCodes.length}개 부서에 ${domain} 도메인이 성공적으로 할당되었습니다.`,
    };

  } catch (error) {
    console.error("부서별 도메인 할당 실패:", error);
    return {
      success: false,
      message: getErrorMessage(error),
    };
  }
}

// 부서별 도메인 할당 수정
export async function updateDepartmentDomainAssignment(params: {
  assignmentId: number;
  domain: UserDomain;
  description?: string;
  isActive?: boolean;
}) {
  unstable_noStore();

  try {
    const session = await getServerSession(authOptions);
    if (!session?.user?.id) {
      return {
        success: false,
        message: "인증이 필요합니다.",
      };
    }

    const { assignmentId, domain, description, isActive = true } = params;
    const userId = parseInt(session.user.id);

    await db.transaction(async (tx) => {
      // 기존 할당 정보 조회
      const existing = await tx
        .select()
        .from(departmentDomainAssignments)
        .where(eq(departmentDomainAssignments.id, assignmentId))
        .limit(1);

      if (existing.length === 0) {
        throw new Error("존재하지 않는 할당 정보입니다.");
      }

      const currentAssignment = existing[0];

      // 히스토리 기록
      await tx.insert(departmentDomainAssignmentHistory).values({
        assignmentId,
        action: "updated",
        previousValues: JSON.stringify({
          assignedDomain: currentAssignment.assignedDomain,
          description: currentAssignment.description,
          isActive: currentAssignment.isActive,
        }),
        newValues: JSON.stringify({
          assignedDomain: domain,
          description,
          isActive,
        }),
        changedBy: userId,
        changeReason: description || "부서별 도메인 할당 수정",
      });

      // 할당 정보 업데이트
      await tx
        .update(departmentDomainAssignments)
        .set({
          assignedDomain: domain,
          description,
          isActive,
          updatedBy: userId,
          updatedAt: new Date(),
        })
        .where(eq(departmentDomainAssignments.id, assignmentId));
    });

    // 캐시 무효화
    revalidateTag("department-domain-assignments");
    revalidatePath("/evcp/menu-access-dept");

    return {
      success: true,
      message: "도메인 할당 정보가 성공적으로 수정되었습니다.",
    };

  } catch (error) {
    console.error("부서별 도메인 할당 수정 실패:", error);
    return {
      success: false,
      message: getErrorMessage(error),
    };
  }
}

// 부서별 도메인 할당 삭제 (soft delete)
export async function deleteDepartmentDomainAssignment(assignmentId: number) {
  unstable_noStore();

  try {
    const session = await getServerSession(authOptions);
    if (!session?.user?.id) {
      return {
        success: false,
        message: "인증이 필요합니다.",
      };
    }

    const userId = parseInt(session.user.id);

    await db.transaction(async (tx) => {
      // 기존 할당 정보 조회
      const existing = await tx
        .select()
        .from(departmentDomainAssignments)
        .where(eq(departmentDomainAssignments.id, assignmentId))
        .limit(1);

      if (existing.length === 0) {
        throw new Error("존재하지 않는 할당 정보입니다.");
      }

      const currentAssignment = existing[0];

      // 히스토리 기록
      await tx.insert(departmentDomainAssignmentHistory).values({
        assignmentId,
        action: "deleted",
        previousValues: JSON.stringify({
          assignedDomain: currentAssignment.assignedDomain,
          description: currentAssignment.description,
          isActive: currentAssignment.isActive,
        }),
        newValues: JSON.stringify({
          isActive: false,
        }),
        changedBy: userId,
        changeReason: "부서별 도메인 할당 삭제",
      });

      // 할당 정보 비활성화
      await tx
        .update(departmentDomainAssignments)
        .set({
          isActive: false,
          updatedBy: userId,
          updatedAt: new Date(),
        })
        .where(eq(departmentDomainAssignments.id, assignmentId));
    });

    // 캐시 무효화
    revalidateTag("department-domain-assignments");
    revalidatePath("/evcp/menu-access-dept");

    return {
      success: true,
      message: "도메인 할당 정보가 성공적으로 삭제되었습니다.",
    };

  } catch (error) {
    console.error("부서별 도메인 할당 삭제 실패:", error);
    return {
      success: false,
      message: getErrorMessage(error),
    };
  }
}

// 부서별 도메인 할당 히스토리 조회
export async function getDepartmentDomainAssignmentHistory(assignmentId?: number) {
  return unstable_cache(
    async () => {
      try {
        const query = db
          .select({
            id: departmentDomainAssignmentHistory.id,
            assignmentId: departmentDomainAssignmentHistory.assignmentId,
            action: departmentDomainAssignmentHistory.action,
            previousValues: departmentDomainAssignmentHistory.previousValues,
            newValues: departmentDomainAssignmentHistory.newValues,
            changedBy: departmentDomainAssignmentHistory.changedBy,
            changeReason: departmentDomainAssignmentHistory.changeReason,
            createdAt: departmentDomainAssignmentHistory.createdAt,
          })
          .from(departmentDomainAssignmentHistory);

        if (assignmentId) {
          query.where(eq(departmentDomainAssignmentHistory.assignmentId, assignmentId));
        }

        const history = await query
          .orderBy(desc(departmentDomainAssignmentHistory.createdAt))
          .limit(100); // 최근 100개 제한

        return history;
      } catch (error) {
        console.error("부서별 도메인 할당 히스토리 조회 실패:", error);
        return [];
      }
    },
    [`department-domain-assignment-history-${assignmentId || 'all'}`],
    {
      revalidate: 1800, // 30분 캐시
      tags: ["department-domain-assignment-history"],
    }
  )();
}

// 도메인별 통계 조회
export async function getDepartmentDomainStats() {
  return unstable_cache(
    async () => {
      try {
        const stats = await db
          .select({
            domain: departmentDomainAssignments.assignedDomain,
            count: db.$count(departmentDomainAssignments),
          })
          .from(departmentDomainAssignments)
          .where(eq(departmentDomainAssignments.isActive, true))
          .groupBy(departmentDomainAssignments.assignedDomain);

        return stats;
      } catch (error) {
        console.error("도메인별 통계 조회 실패:", error);
        return [];
      }
    },
    ["department-domain-stats"],
    {
      revalidate: 3600,
      tags: ["department-domain-assignments"],
    }
  )();
}

// pending 도메인 사용자들의 부서별 도메인 자동 할당
export async function autoAssignPendingUsersDomains() {
  unstable_noStore();
  
  try {
    console.log('[DOMAIN-AUTO-ASSIGN] pending 사용자 도메인 자동 할당 시작');
    
    // 1. pending 도메인 사용자들의 부서 정보 조회
    const pendingUsers = await db
      .select({
        id: users.id,
        email: users.email,
        name: users.name,
        deptCode: users.deptCode,
        deptName: users.deptName,
      })
      .from(users)
      .where(eq(users.domain, 'pending'));

    console.log(`[DOMAIN-AUTO-ASSIGN] pending 사용자 ${pendingUsers.length}명 발견`);

    if (pendingUsers.length === 0) {
      console.log('[DOMAIN-AUTO-ASSIGN] pending 도메인 사용자가 없습니다.');
      return {
        success: true,
        processedCount: 0,
        assignedCount: 0,
        skippedCount: 0,
        message: 'pending 도메인 사용자가 없습니다.',
      };
    }

    // 2. 모든 활성 부서별 도메인 할당 정보 조회
    const domainAssignments = await db
      .select({
        companyCode: departmentDomainAssignments.companyCode,
        departmentCode: departmentDomainAssignments.departmentCode,
        assignedDomain: departmentDomainAssignments.assignedDomain,
      })
      .from(departmentDomainAssignments)
      .where(eq(departmentDomainAssignments.isActive, true));

    // 3. 부서별 도메인 매핑을 위한 Map 생성
    const domainMap = new Map<string, string>();
    domainAssignments.forEach(assignment => {
      const key = `${assignment.companyCode}-${assignment.departmentCode}`;
      domainMap.set(key, assignment.assignedDomain);
    });

    console.log(`[DOMAIN-AUTO-ASSIGN] ${domainAssignments.length}개 부서의 도메인 할당 정보 로드됨`);

    let assignedCount = 0;
    let skippedCount = 0;

    // 4. 각 pending 사용자에 대해 도메인 할당 처리
    for (const user of pendingUsers) {
      try {
        // 사용자의 부서에 대한 도메인 할당 정보 확인
        // 현재 회사 코드 사용 (환경변수 또는 기본값)
        const companyCode = process.env.CURRENT_COMPANY_CODE || 'D60';
        const domainKey = `${companyCode}-${user.deptCode || ''}`;
        const assignedDomain = domainMap.get(domainKey);

        if (assignedDomain && assignedDomain !== 'pending') {
          // 도메인 할당 정보가 있으면 업데이트
          await db
            .update(users)
            .set({
              domain: assignedDomain as UserDomain,
              updatedAt: new Date(),
            })
            .where(eq(users.id, user.id));

          assignedCount++;
          console.log(`[DOMAIN-AUTO-ASSIGN] 사용자 ${user.name}(${user.email}) -> ${assignedDomain} 도메인 할당`);
        } else {
          // 할당 정보가 없으면 pending 유지
          skippedCount++;
          console.log(`[DOMAIN-AUTO-ASSIGN] 사용자 ${user.name}(${user.email}) -> 부서(${user.deptCode})에 대한 도메인 할당 정보 없음, pending 유지`);
        }
      } catch (error) {
        console.error(`[DOMAIN-AUTO-ASSIGN] 사용자 ${user.email} 처리 실패:`, error);
        skippedCount++;
      }
    }

    const result = {
      success: true,
      processedCount: pendingUsers.length,
      assignedCount,
      skippedCount,
      message: `${assignedCount}명의 사용자에게 도메인이 자동 할당되었습니다. (스킵: ${skippedCount}명)`,
    };

    console.log(`[DOMAIN-AUTO-ASSIGN] 완료: ${JSON.stringify(result)}`);
    return result;

  } catch (error) {
    console.error('[DOMAIN-AUTO-ASSIGN] pending 사용자 도메인 자동 할당 실패:', error);
    return {
      success: false,
      processedCount: 0,
      assignedCount: 0,
      skippedCount: 0,
      message: getErrorMessage(error),
    };
  }
}