"use server";

import { createAdminClient } from "@/lib/supabase/server";
import { auth } from "@clerk/nextjs/server";
import type { PerformanceReview } from "./performance-types";

async function getOrganisationId(): Promise<string> {
  const { userId } = await auth();
  if (!userId) throw new Error("Unauthenticated");
  const supabase = await createAdminClient();
  const { data: member, error } = await supabase
    .from("organisation_members")
    .select("organisation_id")
    .eq("user_id", userId)
    .single();
  if (error || !member) throw new Error("No organisation found");
  return member.organisation_id;
}

export async function fetchPerformanceReviews(status?: string): Promise<PerformanceReview[]> {
  const orgId = await getOrganisationId();
  const supabase = await createAdminClient();

  let query = supabase
    .from("performance_reviews")
    .select("*, employee:employees(first_name, last_name), reviewer:employees(first_name, last_name)")
    .eq("organisation_id", orgId)
    .order("created_at", { ascending: false });

  if (status) query = query.eq("status", status);

  const { data, error } = await query;
  if (error) throw error;

  return (data || []).map((r: any) => {
    const emp = Array.isArray(r.employee) ? r.employee[0] : r.employee;
    const rev = Array.isArray(r.reviewer) ? r.reviewer[0] : r.reviewer;
    return {
      id: r.id,
      employee_id: r.employee_id,
      reviewer_id: r.reviewer_id,
      period_start: r.period_start,
      period_end: r.period_end,
      status: r.status,
      overall_rating: r.overall_rating ? Number(r.overall_rating) : null,
      strengths: r.strengths,
      improvements: r.improvements,
      goals_next: r.goals_next,
      created_at: r.created_at,
      employee_name: emp ? `${emp.first_name} ${emp.last_name}` : "Unknown",
      reviewer_name: rev ? `${rev.first_name} ${rev.last_name}` : "Unknown",
    };
  });
}

export async function fetchActiveEmployees(): Promise<{ id: string; first_name: string; last_name: string; job_title: string | null }[]> {
  const orgId = await getOrganisationId();
  const supabase = await createAdminClient();
  const { data, error } = await supabase
    .from("employees")
    .select("id, first_name, last_name, job_title")
    .eq("organisation_id", orgId)
    .eq("status", "active")
    .order("first_name", { ascending: true });
  if (error) throw error;
  return (data || []) as any[];
}

export async function createPerformanceReview(input: {
  employee_id: string;
  reviewer_id: string;
  period_start: string;
  period_end: string;
  overall_rating: number | null;
  strengths: string | null;
  improvements: string | null;
  goals_next: string | null;
}): Promise<{ success: boolean; reviewId?: string; error?: string }> {
  const { userId } = await auth();
  if (!userId) return { success: false, error: "Unauthenticated" };

  const orgId = await getOrganisationId();
  const supabase = await createAdminClient();

  const { data, error } = await supabase
    .from("performance_reviews")
    .insert({
      organisation_id: orgId,
      employee_id: input.employee_id,
      reviewer_id: input.reviewer_id,
      period_start: input.period_start,
      period_end: input.period_end,
      status: "draft",
      overall_rating: input.overall_rating,
      strengths: input.strengths,
      improvements: input.improvements,
      goals_next: input.goals_next,
    })
    .select("id")
    .single();

  if (error) return { success: false, error: error.message };
  return { success: true, reviewId: data.id };
}

export async function submitPerformanceReview(reviewId: string): Promise<{ success: boolean; error?: string }> {
  const orgId = await getOrganisationId();
  const supabase = await createAdminClient();
  const { error } = await supabase
    .from("performance_reviews")
    .update({ status: "completed" })
    .eq("id", reviewId)
    .eq("organisation_id", orgId)
    .eq("status", "draft");
  if (error) return { success: false, error: error.message };
  return { success: true };
}

export async function deletePerformanceReview(reviewId: string): Promise<{ success: boolean; error?: string }> {
  const orgId = await getOrganisationId();
  const supabase = await createAdminClient();
  const { error } = await supabase
    .from("performance_reviews")
    .delete()
    .eq("id", reviewId)
    .eq("organisation_id", orgId);
  if (error) return { success: false, error: error.message };
  return { success: true };
}