"use server";

import db from "@/db/db"
import { items } from "@/db/schema/items"
import { projects } from "@/db/schema/projects"
import {  Tag, tags } from "@/db/schema/vendorData"
import { eq } from "drizzle-orm"
import { revalidateTag, unstable_noStore } from "next/cache";
import { unstable_cache } from "@/lib/unstable-cache";
import { contractItems, contracts } from "@/db/schema/contract";

// 스키마 import

export interface ProjectWithContracts {
    projectId: number
    projectCode: string
    projectName: string
    projectType: string

    contracts: {
        contractId: number
        contractNo: string
        contractName: string
        // contractName 등 필요한 필드 추가
        packages: {
            itemId: number
            itemName: string
        }[]
    }[]
}


export async function getVendorProjectsAndContracts(
    vendorId: number
): Promise<ProjectWithContracts[]> {
    const rows = await db
        .select({
            projectId: projects.id,
            projectCode: projects.code,
            projectName: projects.name,
            projectType: projects.type,

            contractId: contracts.id,
            contractNo: contracts.contractNo,
            contractName: contracts.contractName,

            itemId: contractItems.id,
            itemName: items.itemName,
        })
        .from(contracts)
        .innerJoin(projects, eq(contracts.projectId, projects.id))
        .innerJoin(contractItems, eq(contractItems.contractId, contracts.id))
        .innerJoin(items, eq(contractItems.itemId, items.id))
        .where(eq(contracts.vendorId, vendorId))

    const projectMap = new Map<number, ProjectWithContracts>()

    for (const row of rows) {
        // 1) 프로젝트 그룹 찾기
        let projectEntry = projectMap.get(row.projectId)
        if (!projectEntry) {
            // 새 프로젝트 항목 생성
            projectEntry = {
                projectId: row.projectId,
                projectCode: row.projectCode,
                projectName: row.projectName,
                projectType: row.projectType,
                contracts: [],
            }
            projectMap.set(row.projectId, projectEntry)
        }

        // 2) 프로젝트 안에서 계약(contractId) 찾기
        let contractEntry = projectEntry.contracts.find(
            (c) => c.contractId === row.contractId
        )
        if (!contractEntry) {
            // 새 계약 항목
            contractEntry = {
                contractId: row.contractId,
                contractNo: row.contractNo,
                contractName: row.contractName,
                packages: [],
            }
            projectEntry.contracts.push(contractEntry)
        }

        // 3) 계약의 packages 배열에 아이템 추가
        contractEntry.packages.push({
            itemId: row.itemId,
            itemName: row.itemName,
        })
    }

    return Array.from(projectMap.values())
}


// 1) 태그 조회