"use client";

import { useState, useEffect, useCallback } from "react";
import { fetchApi } from "@/lib/api/http";

const API_BASE_URL =
  process.env.NEXT_PUBLIC_API_BASE_URL || "http://localhost:3007/api";

interface ModuleConfig {
  id: number;
  name: string;
  slug: string;
  button_config: Array<{
    key: string;
    icon: string;
    color: string;
    label: string;
    order: number;
    position: "row" | "toolbar";
  }>;
  column_config: Array<{
    key: string;
    type: string;
    label: string;
    order: number;
    sortable: boolean;
    default_visible: boolean;
  }>;
}

export function useModulePermissions(moduleSlug: string) {
  const [moduleConfig, setModuleConfig] = useState<ModuleConfig | null>(null);
  const [userPermissions, setUserPermissions] = useState<any[]>([]);
  const [permittedActions, setPermittedActions] = useState<Set<string>>(
    new Set(),
  );
  const [visibleFieldKeys, setVisibleFieldKeys] = useState<string[] | null>(
    null,
  );
  const [isReady, setIsReady] = useState(false);

  const getUserId = useCallback((): string | null => {
    if (typeof window === "undefined") return null;

    const tokenKeys = [
      "token",
      "accessToken",
      "access_token",
      "authToken",
      "auth_token",
    ];
    for (const key of tokenKeys) {
      try {
        const raw = localStorage.getItem(key);
        if (!raw) continue;
        const clean = raw.replace(/^Bearer\s+/i, "");
        const payload = JSON.parse(atob(clean.split(".")[1]));
        const id =
          payload?.sub || payload?.id || payload?.userId || payload?.user_id;
        if (id) return String(id);
      } catch {}
    }

    try {
      const stored = localStorage.getItem("user");
      if (stored) {
        const p = JSON.parse(stored);
        const id = p?.id || p?.userId || p?.user_id || p?.sub;
        if (id) return String(id);
      }
    } catch {}

    try {
      const cookies = document.cookie.split(";").map((c) => c.trim());
      for (const cookie of cookies) {
        const [, value] = cookie.split("=");
        if (!value) continue;
        try {
          const clean = value.replace(/^Bearer\s+/i, "");
          const payload = JSON.parse(atob(clean.split(".")[1]));
          const id = payload?.sub || payload?.id || payload?.userId;
          if (id) return String(id);
        } catch {}
      }
    } catch {}

    return null;
  }, []);

  useEffect(() => {
    let cancelled = false;
    const init = async () => {
      try {
        // 1️⃣ Fetch modules
        const modulesRes = await fetchApi<any>(`${API_BASE_URL}/modules`);
        const moduleList = Array.isArray(modulesRes)
          ? modulesRes
          : modulesRes?.data
            ? Array.isArray(modulesRes.data)
              ? modulesRes.data
              : [modulesRes.data]
            : [modulesRes];

        const mod = moduleList.find(
          (m: any) => m.slug === moduleSlug || m.name === moduleSlug,
        );
        if (!mod || cancelled) return;
        setModuleConfig(mod);

        // 🔍 DEBUG LOG 1
        console.log("🔍 [HOOK] moduleSlug:", moduleSlug);
        console.log("🔍 [HOOK] mod.id:", mod.id);

        // 2️⃣ Get userId
        const userId = getUserId();
        console.log("🔍 [HOOK] userId:", userId);

        if (!userId) {
          setIsReady(true);
          return;
        }

        // 3️⃣ Fetch user permissions
        const permsRes = await fetchApi<any>(
          `${API_BASE_URL}/user-permissions/user/${userId}`,
        );
        const permList = Array.isArray(permsRes)
          ? permsRes
          : permsRes?.data
            ? Array.isArray(permsRes.data)
              ? permsRes.data
              : [permsRes.data]
            : (permsRes?.permissions ?? []);

        // 🔍 DEBUG LOG 2 — full raw response
        console.log("🔍 [HOOK] RAW permsRes:", permsRes);
        console.log("🔍 [HOOK] parsed permList:", permList);
        console.log(
          "🔍 [HOOK] permissions summary:",
          permList.map((up: any) => ({
            permission: up.permission?.name,
            action: up.permission?.action,
            module_id: up.permission?.module?.id ?? up.permission?.module_id,
            conditions: up.conditions,
          })),
        );

        if (cancelled) return;
        setUserPermissions(permList);

        // 4️⃣ Build permitted actions
        const actions = new Set<string>();
        for (const up of permList) {
          const perm = up.permission ?? up;
          if (!perm?.action) continue;

          const permModuleId =
            perm.module?.id ??
            perm.module_id ??
            up.module?.id ??
            up.module_id ??
            null;

          if (permModuleId !== null && permModuleId !== undefined) {
            if (permModuleId === mod.id) {
              actions.add(perm.action);
            }
          } else {
            const permName = (perm.name ?? "").toLowerCase();
            const modName = (mod.name ?? "").toLowerCase();
            const modSlug = (mod.slug ?? "").toLowerCase();

            if (
              permName.includes(modName) ||
              permName.includes(modSlug) ||
              permName.startsWith(modName)
            ) {
              actions.add(perm.action);
            }
          }
        }

        // 5️⃣ Build visible form fields from user conditions
        let fieldsCondition: string | null = null;
        for (const up of permList) {
          const mid = up.permission?.module?.id ?? up.permission?.module_id;
          console.log("🔍 [HOOK] checking up:", {
            permission: up.permission?.name,
            mid,
            conditions: up.conditions,
          });
          if (mid && mid !== mod.id) continue;
          for (const c of up.conditions ?? []) {
            const field = c.condition_field || c.field;
            const value = c.condition_value || c.value;
            console.log("🔍 [HOOK] condition found:", { field, value });
            if (field === "visible_fields" && value) {
              fieldsCondition = value;
              break;
            }
          }
          if (fieldsCondition) break;
        }

        const finalKeys = fieldsCondition
          ? fieldsCondition.split(",").map((k) => k.trim())
          : null;

        // 🔍 DEBUG LOG 3
        console.log("🔍 [HOOK] fieldsCondition:", fieldsCondition);
        console.log("🔍 [HOOK] final visibleFieldKeys:", finalKeys);

        setVisibleFieldKeys(finalKeys);
        setPermittedActions(actions);
        setIsReady(true);
      } catch (err) {
        console.error("[useModulePermissions] error:", err);
        setPermittedActions(
          new Set([
            "view",
            "edit",
            "delete",
            "create",
            "export",
            "print",
            "view_all",
          ]),
        );
        setIsReady(true);
      }
    };

    init();
    return () => {
      cancelled = true;
    };
  }, [moduleSlug, getUserId]);

  const canPerform = useCallback(
    (action: string) => isReady && permittedActions.has(action),
    [isReady, permittedActions],
  );

  return {
    canPerform,
    isReady,
    moduleConfig,
    permittedActions,
    userPermissions,
    visibleFieldKeys,
  };
}