"use client";

import { useCallback, useEffect, useState } from "react";
import { createClient, getBrowserUserId } from "@/lib/supabase/client";
import { useWorkspaceStore } from "@/stores/workspace-store";
import type { Priority, RecurrencePattern, TaskStatus, TaskTemplate } from "@/types";

export type TaskTemplateInput = {
  name: string;
  title: string;
  description?: string;
  priority?: Priority;
  status?: TaskStatus;
  tag_ids?: string[];
  recurrence_pattern?: RecurrencePattern;
  recurrence_interval?: number;
};

export function useTaskTemplates() {
  const [templates, setTemplates] = useState<TaskTemplate[]>([]);
  const [loading, setLoading] = useState(true);
  const [userId, setUserId] = useState<string | null>(null);
  const supabase = createClient();
  const activeTeamId = useWorkspaceStore((state) => state.activeTeamId);
  const initialized = useWorkspaceStore((state) => state.initialized);

  useEffect(() => {
    void getBrowserUserId().then(setUserId).catch(() => setUserId(null));
  }, []);

  async function requireCurrentUserId() {
    const currentUserId = userId || (await getBrowserUserId());
    if (currentUserId && currentUserId !== userId) setUserId(currentUserId);
    return currentUserId;
  }

  const fetchTemplates = useCallback(async () => {
    if (!initialized) return;
    setLoading(true);

    let query = supabase
      .from("task_templates")
      .select("*")
      .order("sort_order")
      .order("created_at", { ascending: true });

    query = activeTeamId ? query.eq("team_id", activeTeamId) : query.is("team_id", null);

    const { data, error } = await query;
    if (error) {
      console.error("Failed to load task templates", error);
      setLoading(false);
      return;
    }

    setTemplates((data || []) as TaskTemplate[]);
    setLoading(false);
  }, [activeTeamId, initialized, supabase]);

  useEffect(() => {
    async function loadTemplates() {
      await fetchTemplates();
    }
    void loadTemplates();
  }, [fetchTemplates]);

  async function createTemplate(input: TaskTemplateInput) {
    const currentUserId = await requireCurrentUserId();
    if (!currentUserId) throw new Error("Not authenticated");

    const { error } = await supabase.from("task_templates").insert({
      user_id: currentUserId,
      team_id: activeTeamId,
      name: input.name,
      title: input.title,
      description: input.description || "",
      priority: input.priority || "none",
      status: input.status || "todo",
      tag_ids: input.tag_ids || [],
      recurrence_pattern: input.recurrence_pattern || "none",
      recurrence_interval: input.recurrence_interval || 1,
      sort_order: templates.length,
    });
    if (error) throw error;
    await fetchTemplates();
  }

  async function deleteTemplate(id: string) {
    const { error } = await supabase.from("task_templates").delete().eq("id", id);
    if (error) throw error;
    await fetchTemplates();
  }

  return {
    templates,
    loading,
    createTemplate,
    deleteTemplate,
    refetch: fetchTemplates,
  };
}