"use client";

import { useState, useMemo, useCallback, useEffect } from "react";
import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs";
import { Button } from "@/components/ui/button";
import { Plus, Loader2 } from "lucide-react";
import { StateTable } from "./state-table";
import { AddStateDialog } from "./add-state-dialog";
import { EditStateDialog } from "./edit-state-dialog";
import { DeleteStateDialog } from "./delete-state-dialog";
import { type State } from "@/features/locations/services/locations.service";
import { useToastEnhanced } from "@/hooks/use-toast-enhanced";
import {
  getStatesAction,
  createStateAction,
  updateStateAction,
  deleteStateAction,
} from "@/features/locations/actions/states-actions";
import type { LengthAwarePaginator } from "@/core/api";
import type { State as ApiState } from "@/core/api";

/**
 * Map API State to UI State interface
 */
function mapApiStateToState(apiState: any): State {
  return {
    id: String(apiState.id),
    name: apiState.name,
    status: apiState.status === "active" ? "active" : "inactive",
    createdAt: apiState.created_at || "",
    updatedAt: apiState.updated_at || "",
  };
}

interface StatesClientProps {
  initialData?: LengthAwarePaginator<ApiState>;
  initialSearch?: string;
  initialPage?: number;
}

export function StatesClient({
  initialData,
  initialSearch = "",
  initialPage = 1,
}: StatesClientProps) {
  const toast = useToastEnhanced();
  const [currentTab, setCurrentTab] = useState("all");
  const [isLoading, setIsLoading] = useState(!initialData);

  const [states, setStates] = useState<State[]>(
    initialData ? initialData.data.map(mapApiStateToState) : []
  );
  const [isAddDialogOpen, setIsAddDialogOpen] = useState(false);
  const [editingState, setEditingState] = useState<State | null>(null);
  const [deletingState, setDeletingState] = useState<State | null>(null);

  const loadStates = useCallback(async () => {
    setIsLoading(true);
    try {
      const result = await getStatesAction();
      if (result.success && result.data) {
        const mappedStates = result.data.data.map(mapApiStateToState);
        setStates(mappedStates);
      } else {
        toast.error({
          title: "Error",
          description: result.error || "Failed to load states",
        });
      }
    } catch {
      toast.error({
        title: "Error",
        description: "An unexpected error occurred",
      });
    } finally {
      setIsLoading(false);
    }
  }, [toast]);

  useEffect(() => {
    const isInitialQuery = initialSearch === "" && initialPage === 1;
    if (initialData && isInitialQuery) return;
    loadStates();
  }, [loadStates, initialData, initialSearch, initialPage]);

  const activeStates = useMemo(
    () => states.filter((s) => s.status === "active"),
    [states]
  );
  const inactiveStates = useMemo(
    () => states.filter((s) => s.status === "inactive"),
    [states]
  );

  const handleTabChange = (value: string) => {
    setCurrentTab(value);
  };

  const handleAddState = useCallback(
    async (name: string) => {
      try {
        const result = await createStateAction({ name, status: "active" });
        if (result.success) {
          toast.success({
            title: "State Added",
            description: `${name} has been added successfully.`,
          });
          setIsAddDialogOpen(false);
          loadStates();
          return true;
        }
        toast.error({
          title: "Failed to Add State",
          description: result.error || "An error occurred while adding state.",
        });
      } catch {
        toast.error({
          title: "Error",
          description: "An unexpected error occurred.",
        });
      }
      return false;
    },
    [toast, loadStates]
  );

  const handleEditState = useCallback(
    async (id: string, name: string) => {
      try {
        const stateId = parseInt(id);
        const result = await updateStateAction(stateId, {
          name,
          status: "active",
        });
        if (result.success) {
          toast.success({
            title: "State Updated",
            description: `${name} has been updated successfully.`,
          });
          setEditingState(null);
          loadStates();
          return true;
        }
        toast.error({
          title: "Failed to Update State",
          description:
            result.error || "An error occurred while updating state.",
        });
      } catch {
        toast.error({
          title: "Error",
          description: "An unexpected error occurred.",
        });
      }
      return false;
    },
    [toast, loadStates]
  );

  const handleToggleStatus = useCallback(
    async (state: State) => {
      try {
        const newStatus = state.status === "active" ? "inactive" : "active";
        const result = await updateStateAction(parseInt(state.id), {
          name: state.name,
          status: newStatus,
        });
        if (result.success) {
          loadStates();
          const action = newStatus === "active" ? "activated" : "deactivated";
          toast.success({
            title: `State ${action.charAt(0).toUpperCase() + action.slice(1)}`,
            description: `${state.name} has been ${action}.`,
          });
        } else {
          toast.error({
            title: "Error",
            description: result.error || "Failed to toggle status.",
          });
        }
      } catch {
        toast.error({
          title: "Error",
          description: "An unexpected error occurred.",
        });
      }
    },
    [toast, loadStates]
  );

  const handleDeleteState = useCallback(async () => {
    if (!deletingState) return;

    try {
      const result = await deleteStateAction(parseInt(deletingState.id));
      if (result.success) {
        toast.success({
          title: "State Deleted",
          description: `${deletingState.name} and all its cities have been deleted.`,
        });
        loadStates();
      } else {
        toast.error({
          title: "Error",
          description: result.error || "Failed to delete state.",
        });
      }
    } catch {
      toast.error({
        title: "Error",
        description: "An unexpected error occurred.",
      });
    }
    setDeletingState(null);
  }, [deletingState, toast, loadStates]);

  const getDisplayStates = () => {
    switch (currentTab) {
      case "active":
        return activeStates;
      case "inactive":
        return inactiveStates;
      default:
        return states;
    }
  };

  return (
    <section aria-labelledby="states-heading" className="admin-section">
      <header className="admin-page-header flex flex-col gap-4 sm:flex-row sm:items-center sm:justify-between">
        <div>
          <h1 id="states-heading" className="admin-page-title">
            States
          </h1>
          <p className="admin-page-description">
            Manage states for your platform coverage.
          </p>
        </div>
        <Button
          onClick={() => setIsAddDialogOpen(true)}
          className="w-full sm:w-auto"
        >
          <Plus className="mr-2 h-4 w-4" aria-hidden="true" />
          Add State
        </Button>
      </header>

      {isLoading ? (
        <div className="flex flex-col items-center justify-center py-24 gap-4 animate-in fade-in duration-500">
          <div className="p-3 bg-primary/5 rounded-full ring-8 ring-primary/2">
            <Loader2 className="h-10 w-10 text-primary animate-spin" />
          </div>
          <div className="flex flex-col items-center gap-1">
            <h3 className="text-lg font-semibold text-foreground">
              Loading States
            </h3>
            <p className="text-sm text-muted-foreground">
              Fetching data from server...
            </p>
          </div>
        </div>
      ) : (
        <Tabs
          value={currentTab}
          onValueChange={handleTabChange}
          className="w-full"
        >
          <TabsList className="mb-6 h-auto p-1.5 bg-muted/50 rounded-xl border border-border/50">
            <TabsTrigger
              value="all"
              className="rounded-lg data-[state=active]:bg-background data-[state=active]:shadow-sm px-4 py-2"
            >
              All ({states.length})
            </TabsTrigger>
            <TabsTrigger
              value="active"
              className="rounded-lg data-[state=active]:bg-background data-[state=active]:shadow-sm px-4 py-2"
            >
              Active ({activeStates.length})
            </TabsTrigger>
            <TabsTrigger
              value="inactive"
              className="rounded-lg data-[state=active]:bg-background data-[state=active]:shadow-sm px-4 py-2"
            >
              Inactive ({inactiveStates.length})
            </TabsTrigger>
          </TabsList>

          <TabsContent value="all" className="mt-0">
            <StateTable
              states={getDisplayStates()}
              onEdit={setEditingState}
              onDelete={setDeletingState}
              onToggleStatus={handleToggleStatus}
            />
          </TabsContent>

          <TabsContent value="active" className="mt-0">
            <StateTable
              states={getDisplayStates()}
              onEdit={setEditingState}
              onDelete={setDeletingState}
              onToggleStatus={handleToggleStatus}
            />
          </TabsContent>

          <TabsContent value="inactive" className="mt-0">
            <StateTable
              states={getDisplayStates()}
              onEdit={setEditingState}
              onDelete={setDeletingState}
              onToggleStatus={handleToggleStatus}
            />
          </TabsContent>
        </Tabs>
      )}

      <AddStateDialog
        open={isAddDialogOpen}
        onOpenChange={setIsAddDialogOpen}
        onAdd={handleAddState}
      />

      <EditStateDialog
        state={editingState}
        open={!!editingState}
        onOpenChange={(open) => !open && setEditingState(null)}
        onSave={handleEditState}
      />

      <DeleteStateDialog
        state={deletingState}
        open={!!deletingState}
        onOpenChange={(open) => !open && setDeletingState(null)}
        onConfirm={handleDeleteState}
      />
    </section>
  );
}
