// lib/owner-companies/service.ts
"use server";

// export const dynamic = "force-dynamic";
// export const runtime = "nodejs";

import db from "@/db/db";
import { ownerCompanies, users } from "@/db/schema";
import { revalidatePath, unstable_noStore } from "next/cache";
import { eq } from "drizzle-orm";

export async function createOwnerCompany(data: { name: string }) {
  const [company] = await db
    .insert(ownerCompanies)
    .values({
      name: data.name,
    })
    .returning();

  revalidatePath("/owner-companies");
  return { success: true, data: company };
}

export async function updateOwnerCompany(
  id: number,
  data: { name: string }
) {
  const [company] = await db
    .update(ownerCompanies)
    .set({
      name: data.name,
    })
    .where(eq(ownerCompanies.id, id))
    .returning();

  revalidatePath("/owner-companies");
  revalidatePath(`/owner-companies/${id}`);
  return { success: true, data: company };
}

export async function createOwnerCompanyUser(
  companyId: number,
  data: {
    name: string;
    email: string;
    phone?: string;
    employeeNumber?: string;
  }
) {
  // 이메일 중복 체크
  const existing = await db
    .select()
    .from(users)
    .where(eq(users.email, data.email))
    .limit(1);

  if (existing.length > 0) {
    return { success: false, error: "이미 사용 중인 이메일입니다." };
  }

  const [user] = await db
    .insert(users)
    .values({
      ...data,
      ownerCompanyId: companyId,
      domain: "partners", // 발주처 도메인
      isActive: true,
    })
    .returning();

  revalidatePath(`/evcp/data-room/owner-companies/${companyId}/users`);
  return { success: true, data: user };
}

export async function getOwnerCompanyUsers(companyId: number) {
  return await db
    .select()
    .from(users)
    .where(eq(users.ownerCompanyId, companyId))
    .orderBy(users.createdAt);
}

export const getOwnerCompanyList = async() => {
  unstable_noStore()

  const companies = await db.select().from(ownerCompanies).orderBy(ownerCompanies.createdAt);

  return companies
}


export const getTargetOwnerCompany =  async(companyId:number) => {
  const [company] = await db
      .select()
      .from(ownerCompanies)
      .where(eq(ownerCompanies.id, companyId))
      .limit(1);

      return company
}