"use server";

import { revalidatePath } from "next/cache";
import { redirect } from "next/navigation";
import { prisma } from "@/lib/prisma";
import { SHIPPING_DEFAULTS } from "@/lib/shipping";
import { requirePermission } from "@/lib/permissions";
import { isValidPhone } from "@/lib/phone";

const BASE = "/iv-manage-84x2/shipping";

function revalidateAll() {
  revalidatePath(BASE);
  revalidatePath(`${BASE}/charges`);
  revalidatePath(`${BASE}/pincodes`);
  revalidatePath(`${BASE}/free-shipping`);
  revalidatePath(`${BASE}/couriers`);
  revalidatePath(`${BASE}/tracking`);
}

async function getOrCreateSettingsId(): Promise<string> {
  const row = await prisma.shippingSettings.findFirst();
  if (row) return row.id;
  const created = await prisma.shippingSettings.create({ data: {} });
  return created.id;
}

// ---------- Shipping Methods ----------

export async function createShippingMethod(formData: FormData) {
  await requirePermission("shipping", "add");
  const name = String(formData.get("name") ?? "").trim();
  const estimatedDays = String(formData.get("estimatedDays") ?? "").trim() || null;
  const rateRaw = String(formData.get("ratePerKg") ?? "").trim();
  const ratePerKgPaise = rateRaw ? Math.round(Number(rateRaw) * 100) : SHIPPING_DEFAULTS.ratePerKgPaise;

  if (!name) redirect(`${BASE}?error=Name+is+required`);

  const existingCount = await prisma.shippingMethod.count();
  await prisma.shippingMethod.create({
    data: { name, estimatedDays, ratePerKgPaise, isDefault: existingCount === 0 },
  });
  revalidateAll();
  redirect(`${BASE}?success=Shipping+method+added.`);
}

export async function setDefaultShippingMethod(id: string) {
  await requirePermission("shipping", "edit");
  await prisma.$transaction([
    prisma.shippingMethod.updateMany({ data: { isDefault: false } }),
    prisma.shippingMethod.update({ where: { id }, data: { isDefault: true, active: true } }),
  ]);
  revalidateAll();
  redirect(`${BASE}?success=Default+shipping+method+updated.`);
}

export async function toggleShippingMethod(id: string) {
  await requirePermission("shipping", "edit");
  const method = await prisma.shippingMethod.findUniqueOrThrow({ where: { id } });
  if (method.isDefault) redirect(`${BASE}?error=Set+a+different+default+before+deactivating+this+one`);
  await prisma.shippingMethod.update({ where: { id }, data: { active: !method.active } });
  revalidateAll();
  redirect(`${BASE}?success=Shipping+method+updated.`);
}

export async function deleteShippingMethod(id: string) {
  await requirePermission("shipping", "delete");
  const method = await prisma.shippingMethod.findUniqueOrThrow({ where: { id } });
  if (method.isDefault) redirect(`${BASE}?error=Set+a+different+default+before+deleting+this+one`);
  await prisma.shippingMethod.delete({ where: { id } });
  revalidateAll();
  redirect(`${BASE}?success=Shipping+method+deleted.`);
}

// ---------- Delivery Charges (per-method rate + calc mechanics) ----------

export async function updateShippingMethodRate(id: string, formData: FormData) {
  await requirePermission("shipping", "edit");
  const rateRaw = String(formData.get("ratePerKg") ?? "").trim();
  const rateNum = Number(rateRaw);
  if (!Number.isFinite(rateNum)) redirect(`${BASE}/charges?error=Enter+a+valid+rate`);
  const ratePerKgPaise = Math.max(0, Math.round(rateNum * 100));
  await prisma.shippingMethod.update({ where: { id }, data: { ratePerKgPaise } });
  revalidateAll();
  redirect(`${BASE}/charges?success=Rate+updated.`);
}

export async function updateDeliveryChargeMechanics(formData: FormData) {
  await requirePermission("shipping", "edit");
  const id = await getOrCreateSettingsId();
  const weightSlabRaw = Number(formData.get("weightSlabGrams") ?? SHIPPING_DEFAULTS.weightSlabGrams);
  const minBillableRaw = Number(formData.get("minBillableWeightGrams") ?? SHIPPING_DEFAULTS.minBillableWeightGrams);
  const defaultItemRaw = Number(formData.get("defaultItemWeightGrams") ?? SHIPPING_DEFAULTS.defaultItemWeightGrams);
  if (!Number.isFinite(weightSlabRaw) || !Number.isFinite(minBillableRaw) || !Number.isFinite(defaultItemRaw)) {
    redirect(`${BASE}/charges?error=Enter+valid+weight+numbers`);
  }
  const weightSlabGrams = Math.max(1, Math.round(weightSlabRaw));
  const minBillableWeightGrams = Math.max(0, Math.round(minBillableRaw));
  const defaultItemWeightGrams = Math.max(1, Math.round(defaultItemRaw));

  await prisma.shippingSettings.update({
    where: { id },
    data: { weightSlabGrams, minBillableWeightGrams, defaultItemWeightGrams },
  });
  revalidateAll();
  redirect(`${BASE}/charges?success=Delivery+charge+settings+updated.`);
}

// ---------- Free Shipping ----------

export async function updateFreeShippingThreshold(formData: FormData) {
  await requirePermission("shipping", "edit");
  const id = await getOrCreateSettingsId();
  const raw = String(formData.get("freeShippingThreshold") ?? "").trim();
  const rawNum = raw ? Number(raw) : 0;
  if (!Number.isFinite(rawNum)) redirect(`${BASE}/free-shipping?error=Enter+a+valid+amount`);
  const freeShippingThreshold = Math.max(0, Math.round(rawNum * 100));
  await prisma.shippingSettings.update({ where: { id }, data: { freeShippingThreshold } });
  revalidateAll();
  redirect(`${BASE}/free-shipping?success=Free+shipping+threshold+updated.`);
}

// ---------- Pincode Serviceability ----------

export async function addNonServiceablePincode(formData: FormData) {
  await requirePermission("shipping", "add");
  const pincode = String(formData.get("pincode") ?? "").trim();
  const reason = String(formData.get("reason") ?? "").trim() || null;
  if (!/^\d{4,10}$/.test(pincode)) redirect(`${BASE}/pincodes?error=Enter+a+valid+pincode`);

  const existing = await prisma.nonServiceablePincode.findUnique({ where: { pincode } });
  if (existing) redirect(`${BASE}/pincodes?error=That+pincode+is+already+on+the+list`);

  await prisma.nonServiceablePincode.create({ data: { pincode, reason } });
  revalidateAll();
  redirect(`${BASE}/pincodes?success=Pincode+added.`);
}

export async function deleteNonServiceablePincode(id: string) {
  await requirePermission("shipping", "delete");
  await prisma.nonServiceablePincode.delete({ where: { id } });
  revalidateAll();
  redirect(`${BASE}/pincodes?success=Pincode+removed.`);
}

// ---------- Courier Partners ----------

export async function createCourierPartner(formData: FormData) {
  await requirePermission("shipping", "add");
  const name = String(formData.get("name") ?? "").trim();
  const phone = String(formData.get("phone") ?? "").trim() || null;
  const notes = String(formData.get("notes") ?? "").trim() || null;
  if (!name) redirect(`${BASE}/couriers?error=Name+is+required`);
  if (phone && !isValidPhone(phone)) redirect(`${BASE}/couriers?error=Enter+a+valid+10-digit+mobile+number`);

  await prisma.courierPartner.create({ data: { name, phone, notes } });
  revalidateAll();
  redirect(`${BASE}/couriers?success=Courier+partner+added.`);
}

export async function toggleCourierPartner(id: string) {
  await requirePermission("shipping", "edit");
  const partner = await prisma.courierPartner.findUniqueOrThrow({ where: { id } });
  await prisma.courierPartner.update({ where: { id }, data: { active: !partner.active } });
  revalidateAll();
  redirect(`${BASE}/couriers?success=Courier+partner+updated.`);
}

export async function deleteCourierPartner(id: string) {
  await requirePermission("shipping", "delete");
  await prisma.courierPartner.delete({ where: { id } });
  revalidateAll();
  redirect(`${BASE}/couriers?success=Courier+partner+deleted.`);
}