"use server";

import config from "@payload-config";
import { getPayload } from "payload";
import type { Asset, Loadout, LockerStorage, User } from "@/payload-types";
import hasRoles from "@/utils/access-control/hasRoles";
import { emitGameEvent } from "@/utils/event-log/emit";
import { EventTypes } from "@/utils/event-log/eventTypes";
import {
  autoArrangeLockerItems,
  ensureLockerStorage,
  findLockerEmptySpot,
  getLockerGridDimensions,
  getLockerItemFootprint,
  getLoadoutSlot,
  isLockerPlacementValid,
  lockerIsRotatable,
  lockerIsStackable,
  lockerMaxStack,
  type LockerGridItem,
} from "@/lib/locker";

interface ActionResult<T = undefined> {
  success: boolean;
  error?: string;
  data?: T;
}

async function authenticate() {
  const payloadConfig = await config;
  const payload = await getPayload({ config: payloadConfig });
  const { headers } = await import("next/headers");
  const hdrs = await headers();
  const { user } = await payload.auth({ headers: hdrs, canSetHeaders: false });

  if (!user) {
    throw new Error("Unauthorized");
  }

  return { payload, user };
}

function isLockerManager(user: User): boolean {
  return hasRoles(["admin", "developer"], user);
}

function toGridItems(items: LockerStorage["items"]): LockerGridItem[] {
  return (items ?? [])
    .filter((e) => e.asset && typeof e.asset === "object" && "id" in e.asset)
    .map((e) => {
      const asset = e.asset as Asset;
      return {
        id: e.id ?? `${asset.id}-${e.gridX}-${e.gridY}`,
        assetId: asset.id,
        quantity: e.quantity,
        gridX: e.gridX ?? 0,
        gridY: e.gridY ?? 0,
        rotated: e.rotated ?? false,
        asset,
      };
    });
}

function resolveAssetId(asset: NonNullable<LockerStorage["items"]>[number]["asset"]): number | null {
  if (asset == null) return null;
  if (typeof asset === "object" && "id" in asset) return asset.id as number;
  return asset as number;
}

async function getLockerWithItems(
  payload: Awaited<ReturnType<typeof getPayload>>,
  userId: number,
): Promise<LockerStorage> {
  const locker = await ensureLockerStorage(payload, userId);
  return (await payload.findByID({
    collection: "locker-storages",
    id: locker.id,
    depth: 2,
    overrideAccess: true,
  })) as unknown as LockerStorage;
}

async function getAssetOrThrow(
  payload: Awaited<ReturnType<typeof getPayload>>,
  assetId: number,
): Promise<Asset> {
  const asset = (await payload
    .findByID({ collection: "assets", id: assetId, depth: 0, overrideAccess: true })
    .catch(() => null)) as unknown as Asset | null;
  if (!asset) throw new Error("Asset not found.");
  return asset;
}

export async function ensureLocker(): Promise<ActionResult<number>> {
  try {
    const { payload, user } = await authenticate();
    const locker = await ensureLockerStorage(payload, user.id as number);
    const existing = await payload.find({
      collection: "game-event-logs",
      where: {
        and: [
          { type: { equals: EventTypes.LockerCreate } },
          { targetCollection: { equals: "locker-storages" } },
          { targetId: { equals: locker.id } },
        ],
      },
      limit: 1,
      depth: 0,
      overrideAccess: true,
    });
    if (existing.docs.length === 0) {
      await emitGameEvent(payload, {
        type: EventTypes.LockerCreate,
        message: `Personal locker provisioned`,
        actor: user.id,
        targetCollection: "locker-storages",
        targetId: locker.id,
      });
    }
    return { success: true, data: locker.id };
  } catch (error) {
    const message = error instanceof Error ? error.message : "Unknown error";
    return message === "Unauthorized"
      ? { success: false, error: "You must be logged in." }
      : { success: false, error: message };
  }
}

export async function addItemToLocker(
  assetId: number,
  quantity: number,
): Promise<ActionResult<LockerStorage>> {
  try {
    const { payload, user } = await authenticate();
    if (!isLockerManager(user)) {
      return {
        success: false,
        error: "Insufficient permissions. Admin or Developer role required to add items.",
      };
    }
    if (!Number.isInteger(quantity) || quantity <= 0) {
      return { success: false, error: "Quantity must be a positive integer." };
    }

    const asset = await getAssetOrThrow(payload, assetId);
    const locker = await getLockerWithItems(payload, user.id as number);
    const grid = await getLockerGridDimensions(payload);

    const existing = [...(locker.items ?? [])];
    const gridItems = toGridItems(existing);
    const stackable = lockerIsStackable(asset);
    const maxStack = lockerMaxStack(asset);
    const fp = getLockerItemFootprint(asset, false);

    let remaining = quantity;

    if (stackable) {
      const sameType = gridItems.filter((e) => e.assetId === assetId);
      for (const entry of sameType) {
        if (remaining <= 0) break;
        const space =
          maxStack === Infinity
            ? remaining
            : Math.max(0, Math.min(maxStack - entry.quantity, remaining));
        if (space <= 0) continue;
        const idx = existing.findIndex((e) => e.id === entry.id);
        if (idx >= 0) {
          existing[idx] = { ...existing[idx], quantity: existing[idx].quantity + space };
          remaining -= space;
        }
      }
    }

    while (remaining > 0) {
      const stackAmount = Math.min(remaining, maxStack === Infinity ? remaining : maxStack);
      const spot = findLockerEmptySpot(gridItems, fp.width, fp.height, grid.width, grid.height);
      if (!spot) {
        return {
          success: false,
          error: `No space in locker for ${asset.name}. Need ${fp.width}×${fp.height} free cells.`,
        };
      }
      existing.push({
        asset: assetId,
        quantity: stackAmount,
        gridX: spot.x,
        gridY: spot.y,
        rotated: false,
      });
      gridItems.push({
        id: `new-${existing.length}`,
        assetId,
        quantity: stackAmount,
        gridX: spot.x,
        gridY: spot.y,
        rotated: false,
        asset,
      });
      remaining -= stackAmount;
    }

    const added = quantity - remaining;
    const updated = (await payload.update({
      collection: "locker-storages",
      id: locker.id,
      data: { items: existing },
      overrideAccess: true,
      depth: 0,
    })) as unknown as LockerStorage;

    await emitGameEvent(payload, {
      type: EventTypes.LockerAddItem,
      message: `Added ${added.toLocaleString()}× ${asset.name} to locker`,
      actor: user.id,
      targetCollection: "locker-storages",
      targetId: locker.id,
      data: { assetId, assetName: asset.name, quantity: added },
    });

    return { success: true, data: updated };
  } catch (error) {
    const message = error instanceof Error ? error.message : "Unknown error";
    return message === "Unauthorized"
      ? { success: false, error: "You must be logged in." }
      : { success: false, error: message };
  }
}

export async function removeLockerItem(entryId: string): Promise<ActionResult> {
  try {
    const { payload, user } = await authenticate();
    const locker = await getLockerWithItems(payload, user.id as number);
    const items = [...(locker.items ?? [])];
    const idx = items.findIndex((e) => e.id === entryId);
    if (idx < 0) return { success: false, error: "Item not found in locker." };

    const removed = items[idx];
    const asset = removed.asset as Asset;
    const removedName = typeof asset === "object" && asset ? asset.name : `asset #${resolveAssetId(removed.asset)}`;

    items.splice(idx, 1);
    await payload.update({
      collection: "locker-storages",
      id: locker.id,
      data: { items },
      overrideAccess: true,
      depth: 0,
    });

    await emitGameEvent(payload, {
      type: EventTypes.LockerRemoveItem,
      message: `Removed ${removed.quantity}× ${removedName} from locker`,
      actor: user.id,
      targetCollection: "locker-storages",
      targetId: locker.id,
      data: { entryId, assetId: resolveAssetId(removed.asset), assetName: removedName, quantity: removed.quantity },
    });

    return { success: true };
  } catch (error) {
    const message = error instanceof Error ? error.message : "Unknown error";
    return message === "Unauthorized"
      ? { success: false, error: "You must be logged in." }
      : { success: false, error: message };
  }
}

export async function moveLockerItem(
  entryId: string,
  gridX: number,
  gridY: number,
  rotated?: boolean,
): Promise<ActionResult> {
  try {
    const { payload, user } = await authenticate();
    const locker = await getLockerWithItems(payload, user.id as number);
    const grid = await getLockerGridDimensions(payload);
    const items = [...(locker.items ?? [])];
    const idx = items.findIndex((e) => e.id === entryId);
    if (idx < 0) return { success: false, error: "Item not found in locker." };

    const entry = items[idx];
    const asset = entry.asset as Asset;
    if (!asset || typeof asset === "number") return { success: false, error: "Invalid asset." };

    const effectiveRotated = rotated ?? entry.rotated ?? false;
    const fp = getLockerItemFootprint(asset, effectiveRotated);

    if (gridX < 0 || gridY < 0 || gridX + fp.width > grid.width || gridY + fp.height > grid.height) {
      return { success: false, error: "Placement is outside grid bounds." };
    }

    const gridItems = toGridItems(items);
    if (!isLockerPlacementValid(gridItems, entryId, gridX, gridY, fp.width, fp.height, grid.width, grid.height)) {
      return { success: false, error: "Cannot move here — overlaps with another item." };
    }

    items[idx] =
      rotated !== undefined
        ? { ...entry, gridX, gridY, rotated }
        : { ...entry, gridX, gridY };

    await payload.update({
      collection: "locker-storages",
      id: locker.id,
      data: { items },
      overrideAccess: true,
      depth: 0,
    });

    await emitGameEvent(payload, {
      type: EventTypes.LockerGridMove,
      message: `Moved ${asset.name} to (${gridX}, ${gridY}) in locker`,
      actor: user.id,
      targetCollection: "locker-storages",
      targetId: locker.id,
      data: { entryId, assetId: asset.id, assetName: asset.name, gridX, gridY, rotated: effectiveRotated },
    });

    return { success: true };
  } catch (error) {
    const message = error instanceof Error ? error.message : "Unknown error";
    return message === "Unauthorized"
      ? { success: false, error: "You must be logged in." }
      : { success: false, error: message };
  }
}

export async function rotateLockerItem(entryId: string): Promise<ActionResult> {
  try {
    const { payload, user } = await authenticate();
    const locker = await getLockerWithItems(payload, user.id as number);
    const grid = await getLockerGridDimensions(payload);
    const items = [...(locker.items ?? [])];
    const idx = items.findIndex((e) => e.id === entryId);
    if (idx < 0) return { success: false, error: "Item not found in locker." };

    const entry = items[idx];
    const asset = entry.asset as Asset;
    if (!asset || typeof asset === "number") return { success: false, error: "Invalid asset." };
    if (!lockerIsRotatable(asset)) return { success: false, error: "This asset cannot be rotated." };

    const newRotated = !(entry.rotated ?? false);
    const fp = getLockerItemFootprint(asset, newRotated);

    if (entry.gridX + fp.width > grid.width || entry.gridY + fp.height > grid.height) {
      return { success: false, error: "Rotation would push the item out of bounds." };
    }

    const gridItems = toGridItems(items);
    if (!isLockerPlacementValid(gridItems, entryId, entry.gridX, entry.gridY, fp.width, fp.height, grid.width, grid.height)) {
      return { success: false, error: "Rotation would overlap with another item." };
    }

    items[idx] = { ...entry, rotated: newRotated };
    await payload.update({
      collection: "locker-storages",
      id: locker.id,
      data: { items },
      overrideAccess: true,
      depth: 0,
    });

    await emitGameEvent(payload, {
      type: EventTypes.LockerGridRotate,
      message: `Rotated ${asset.name} in locker`,
      actor: user.id,
      targetCollection: "locker-storages",
      targetId: locker.id,
      data: { entryId, assetId: asset.id, assetName: asset.name, rotated: newRotated },
    });

    return { success: true };
  } catch (error) {
    const message = error instanceof Error ? error.message : "Unknown error";
    return message === "Unauthorized"
      ? { success: false, error: "You must be logged in." }
      : { success: false, error: message };
  }
}

export async function mergeLockerStacks(
  sourceId: string,
  targetId: string,
): Promise<ActionResult> {
  try {
    const { payload, user } = await authenticate();
    const locker = await getLockerWithItems(payload, user.id as number);
    const items = [...(locker.items ?? [])];

    const srcIdx = items.findIndex((e) => e.id === sourceId);
    const tgtIdx = items.findIndex((e) => e.id === targetId);
    if (srcIdx < 0 || tgtIdx < 0) return { success: false, error: "Item not found." };

    const src = items[srcIdx];
    const tgt = items[tgtIdx];
    const srcAsset = src.asset as Asset;
    const tgtAsset = tgt.asset as Asset;
    if (!srcAsset || typeof srcAsset === "number" || !tgtAsset || typeof tgtAsset === "number") {
      return { success: false, error: "Invalid asset." };
    }
    if (srcAsset.id !== tgtAsset.id) {
      return { success: false, error: "Cannot merge different asset types." };
    }
    if (!lockerIsStackable(tgtAsset)) return { success: false, error: "This asset cannot be stacked." };

    const maxStack = lockerMaxStack(tgtAsset);
    const spaceInTarget = maxStack === Infinity ? Infinity : Math.max(0, maxStack - tgt.quantity);
    if (spaceInTarget <= 0) return { success: false, error: "Target stack is full." };

    const transferAmount = Math.min(src.quantity, spaceInTarget);
    items[tgtIdx] = { ...tgt, quantity: tgt.quantity + transferAmount };

    if (transferAmount >= src.quantity) {
      items.splice(srcIdx, 1);
    } else {
      items[srcIdx] = { ...src, quantity: src.quantity - transferAmount };
    }

    await payload.update({
      collection: "locker-storages",
      id: locker.id,
      data: { items },
      overrideAccess: true,
      depth: 0,
    });

    await emitGameEvent(payload, {
      type: EventTypes.LockerGridMerge,
      message: `Merged ${transferAmount}× ${tgtAsset.name} stacks in locker`,
      actor: user.id,
      targetCollection: "locker-storages",
      targetId: locker.id,
      data: { sourceId, targetId, assetId: srcAsset.id, assetName: tgtAsset.name, transferAmount },
    });

    return { success: true };
  } catch (error) {
    const message = error instanceof Error ? error.message : "Unknown error";
    return message === "Unauthorized"
      ? { success: false, error: "You must be logged in." }
      : { success: false, error: message };
  }
}

export async function splitLockerStack(entryId: string, splitAmount: number): Promise<ActionResult> {
  try {
    const { payload, user } = await authenticate();
    if (!Number.isInteger(splitAmount) || splitAmount <= 0) {
      return { success: false, error: "Split amount must be a positive integer." };
    }

    const locker = await getLockerWithItems(payload, user.id as number);
    const grid = await getLockerGridDimensions(payload);
    const items = [...(locker.items ?? [])];
    const idx = items.findIndex((e) => e.id === entryId);
    if (idx < 0) return { success: false, error: "Item not found in locker." };

    const entry = items[idx];
    if (splitAmount >= entry.quantity) {
      return { success: false, error: "Split amount must be less than the stack size." };
    }
    const asset = entry.asset as Asset;
    if (!asset || typeof asset === "number") return { success: false, error: "Invalid asset." };
    if (!lockerIsStackable(asset)) return { success: false, error: "This asset cannot be stacked." };

    const gridItems = toGridItems(items);
    const fp = getLockerItemFootprint(asset, entry.rotated ?? false);
    const spot = findLockerEmptySpot(gridItems, fp.width, fp.height, grid.width, grid.height);
    if (!spot) return { success: false, error: "No empty spot available for the split stack." };

    items[idx] = { ...entry, quantity: entry.quantity - splitAmount };
    items.push({
      asset: entry.asset,
      quantity: splitAmount,
      gridX: spot.x,
      gridY: spot.y,
      rotated: entry.rotated ?? false,
    });

    await payload.update({
      collection: "locker-storages",
      id: locker.id,
      data: { items },
      overrideAccess: true,
      depth: 0,
    });

    await emitGameEvent(payload, {
      type: EventTypes.LockerGridSplit,
      message: `Split ${splitAmount}× ${asset.name} from stack in locker`,
      actor: user.id,
      targetCollection: "locker-storages",
      targetId: locker.id,
      data: { entryId, assetId: asset.id, assetName: asset.name, splitAmount, remainingAmount: entry.quantity - splitAmount },
    });

    return { success: true };
  } catch (error) {
    const message = error instanceof Error ? error.message : "Unknown error";
    return message === "Unauthorized"
      ? { success: false, error: "You must be logged in." }
      : { success: false, error: message };
  }
}

export async function autoArrangeLocker(): Promise<ActionResult> {
  try {
    const { payload, user } = await authenticate();
    const locker = await getLockerWithItems(payload, user.id as number);
    const grid = await getLockerGridDimensions(payload);

    const items = [...(locker.items ?? [])];
    const rearranged = autoArrangeLockerItems(toGridItems(items), grid.width, grid.height);

    const updatedItems = items.map((entry) => {
      const match = rearranged.find((r) => r.id === entry.id);
      return match ? { ...entry, gridX: match.gridX, gridY: match.gridY } : entry;
    });

    await payload.update({
      collection: "locker-storages",
      id: locker.id,
      data: { items: updatedItems },
      overrideAccess: true,
      depth: 0,
    });

    await emitGameEvent(payload, {
      type: EventTypes.LockerGridArrange,
      message: "Arranged locker grid",
      actor: user.id,
      targetCollection: "locker-storages",
      targetId: locker.id,
      data: { itemCount: updatedItems.length },
    });

    return { success: true };
  } catch (error) {
    const message = error instanceof Error ? error.message : "Unknown error";
    return message === "Unauthorized"
      ? { success: false, error: "You must be logged in." }
      : { success: false, error: message };
  }
}

// --- Loadouts ---

export async function createLoadout(input: {
  name: string;
  description?: string;
}): Promise<ActionResult<number>> {
  try {
    const { payload, user } = await authenticate();
    if (!input.name?.trim()) {
      return { success: false, error: "A loadout name is required." };
    }
    const loadout = (await payload.create({
      collection: "loadouts",
      data: {
        name: input.name.trim(),
        description: input.description?.trim() || null,
        ownerUser: user.id as number,
        slots: {},
      },
      overrideAccess: true,
      depth: 0,
    })) as unknown as Loadout;

    await emitGameEvent(payload, {
      type: EventTypes.LoadoutCreate,
      message: `Created loadout "${loadout.name}"`,
      actor: user.id,
      targetCollection: "loadouts",
      targetId: loadout.id,
      data: { loadoutName: loadout.name },
    });

    return { success: true, data: loadout.id };
  } catch (error) {
    const message = error instanceof Error ? error.message : "Unknown error";
    return message === "Unauthorized"
      ? { success: false, error: "You must be logged in." }
      : { success: false, error: message };
  }
}

export async function updateLoadout(
  id: number,
  input: { name?: string; description?: string },
): Promise<ActionResult> {
  try {
    const { payload, user } = await authenticate();
    const loadout = await getOwnedLoadout(payload, user, id);
    if (!loadout) return { success: false, error: "Loadout not found." };

    const data: { name?: string; description?: string | null } = {};
    if (input.name?.trim()) data.name = input.name.trim();
    if (input.description !== undefined) data.description = input.description?.trim() || null;

    const updated = (await payload.update({
      collection: "loadouts",
      id,
      data,
      overrideAccess: true,
      depth: 0,
    })) as unknown as Loadout;

    await emitGameEvent(payload, {
      type: EventTypes.LoadoutUpdate,
      message: `Updated loadout "${updated.name}"`,
      actor: user.id,
      targetCollection: "loadouts",
      targetId: id,
      data: { loadoutName: updated.name },
    });

    return { success: true };
  } catch (error) {
    const message = error instanceof Error ? error.message : "Unknown error";
    return message === "Unauthorized"
      ? { success: false, error: "You must be logged in." }
      : { success: false, error: message };
  }
}

export async function deleteLoadout(id: number): Promise<ActionResult> {
  try {
    const { payload, user } = await authenticate();
    const loadout = await getOwnedLoadout(payload, user, id);
    if (!loadout) return { success: false, error: "Loadout not found." };

    await payload.delete({ collection: "loadouts", id, overrideAccess: true });

    await emitGameEvent(payload, {
      type: EventTypes.LoadoutDelete,
      message: `Deleted loadout "${loadout.name}"`,
      actor: user.id,
      targetCollection: "loadouts",
      targetId: id,
      data: { loadoutName: loadout.name },
    });

    return { success: true };
  } catch (error) {
    const message = error instanceof Error ? error.message : "Unknown error";
    return message === "Unauthorized"
      ? { success: false, error: "You must be logged in." }
      : { success: false, error: message };
  }
}

export async function setLoadoutSlot(
  loadoutId: number,
  slot: string,
  assetId: number | null,
): Promise<ActionResult> {
  try {
    const { payload, user } = await authenticate();
    const slotConfig = getLoadoutSlot(slot);
    if (!slotConfig) return { success: false, error: "Unknown loadout slot." };

    const loadout = await getOwnedLoadout(payload, user, loadoutId, 1);
    if (!loadout) return { success: false, error: "Loadout not found." };

    if (assetId !== null) {
      const asset = await getAssetOrThrow(payload, assetId);
      const allowed = slotConfig.assetTypes.includes(asset.assetType);
      if (!allowed) {
        return {
          success: false,
          error: `"${asset.name}" cannot be equipped in the ${slotConfig.label} slot.`,
        };
      }
      const locker = await getLockerWithItems(payload, user.id as number);
      const owned = (locker.items ?? []).some((e) => resolveAssetId(e.asset) === assetId);
      if (!owned) {
        return { success: false, error: "You can only equip assets from your own locker." };
      }
    }

    const currentSlots = (loadout.slots as Record<string, unknown> | null) ?? {};
    const updatedSlots = { ...currentSlots, [slot]: assetId ?? null };

    await payload.update({
      collection: "loadouts",
      id: loadoutId,
      data: { slots: updatedSlots },
      overrideAccess: true,
      depth: 0,
    });

    const equippedName = assetId
      ? (await getAssetOrThrow(payload, assetId).catch(() => null))?.name ?? `asset #${assetId}`
      : null;

    await emitGameEvent(payload, {
      type: EventTypes.LoadoutEquip,
      message: equippedName
        ? `Equipped ${equippedName} to "${loadout.name}" ${slotConfig.label} slot`
        : `Cleared ${slotConfig.label} slot on "${loadout.name}"`,
      actor: user.id,
      targetCollection: "loadouts",
      targetId: loadoutId,
      data: { loadoutId, slot, assetId, assetName: equippedName },
    });

    return { success: true };
  } catch (error) {
    const message = error instanceof Error ? error.message : "Unknown error";
    return message === "Unauthorized"
      ? { success: false, error: "You must be logged in." }
      : { success: false, error: message };
  }
}

async function getOwnedLoadout(
  payload: Awaited<ReturnType<typeof getPayload>>,
  user: User,
  id: number,
  depth = 0,
): Promise<Loadout | null> {
  const loadout = (await payload
    .findByID({ collection: "loadouts", id, depth, overrideAccess: true })
    .catch(() => null)) as unknown as Loadout | null;
  if (!loadout) return null;

  const ownerId =
    typeof loadout.ownerUser === "object" && loadout.ownerUser
      ? (loadout.ownerUser as { id: number }).id
      : (loadout.ownerUser as number);

  if (ownerId !== user.id && !isLockerManager(user)) return null;
  return loadout;
}