import { defineStore } from "pinia";

export const useBudgetStore = defineStore(
  "budget",
  () => {
    // Schema version for persistence
    const schemaVersion = "2.0";

    // Canonical categories from WizardRevenueStep - matches the wizard exactly
    const revenueCategories = ref([
      "Games & Products",
      "Services & Contracts",
      "Grants & Funding",
      "Community Support",
      "Partnerships",
      "Investment Income",
      "In-Kind Contributions",
    ]);

    // Revenue subcategories by main category (for reference and grouping)
    const revenueSubcategories = ref({
      "Games & Products": [
        "Direct sales",
        "Platform revenue share",
        "DLC/expansions",
        "Merchandise",
      ],
      "Services & Contracts": [
        "Contract development",
        "Consulting",
        "Workshops/teaching",
        "Technical services",
      ],
      "Grants & Funding": [
        "Government funding",
        "Arts council grants",
        "Foundation support",
        "Research grants",
      ],
      "Community Support": [
        "Patreon/subscriptions",
        "Crowdfunding",
        "Donations",
        "Mutual aid received",
      ],
      Partnerships: [
        "Corporate partnerships",
        "Academic partnerships",
        "Sponsorships",
      ],
      "Investment Income": ["Impact investment", "Venture capital", "Loans"],
      "In-Kind Contributions": [
        "Office space",
        "Equipment/hardware",
        "Software licenses",
        "Professional services",
        "Marketing/PR services",
        "Legal services",
      ],
    });

    const expenseCategories = ref([
      "Salaries & Benefits",
      "Development Costs",
      "Equipment & Technology",
      "Marketing & Outreach",
      "Office & Operations",
      "Legal & Professional",
      "Other Expenses",
    ]);

    // NEW: Budget worksheet structure (starts empty, populated from wizard data)
    const budgetWorksheet = ref({
      revenue: [],
      expenses: [],
    });

    // Track if worksheet has been initialized from wizard data
    const isInitialized = ref(false);

    // LEGACY: Keep for backward compatibility
    const budgetLines = ref({});
    const overheadCosts = ref([]);
    const productionCosts = ref([]);

    // Computed grouped data for category headers
    const groupedRevenue = computed(() => {
      const groups: Record<string, any[]> = {};
      revenueCategories.value.forEach((category) => {
        groups[category] = budgetWorksheet.value.revenue.filter(
          (item) => item.mainCategory === category
        );
      });
      return groups;
    });

    const groupedExpenses = computed(() => {
      const groups: Record<string, any[]> = {};
      expenseCategories.value.forEach((category) => {
        groups[category] = budgetWorksheet.value.expenses.filter(
          (item) => item.mainCategory === category
        );
      });
      return groups;
    });

    // Computed totals for budget worksheet (legacy - keep for backward compatibility)
    const budgetTotals = computed(() => {
      const years = ["year1", "year2", "year3"];
      const scenarios = ["best", "worst", "mostLikely"];
      const totals = {};

      years.forEach((year) => {
        totals[year] = {};
        scenarios.forEach((scenario) => {
          // Calculate revenue total
          const revenueTotal = budgetWorksheet.value.revenue.reduce(
            (sum, item) => {
              return sum + (item.values?.[year]?.[scenario] || 0);
            },
            0
          );

          // Calculate expenses total
          const expensesTotal = budgetWorksheet.value.expenses.reduce(
            (sum, item) => {
              return sum + (item.values?.[year]?.[scenario] || 0);
            },
            0
          );

          // Calculate net income
          const netIncome = revenueTotal - expensesTotal;

          totals[year][scenario] = {
            revenue: revenueTotal,
            expenses: expensesTotal,
            net: netIncome,
          };
        });
      });

      return totals;
    });

    // Monthly totals computation
    const monthlyTotals = computed(() => {
      const totals: Record<
        string,
        { revenue: number; expenses: number; net: number }
      > = {};

      // Generate month keys for next 12 months
      const today = new Date();
      for (let i = 0; i < 12; i++) {
        const date = new Date(today.getFullYear(), today.getMonth() + i, 1);
        const monthKey = `${date.getFullYear()}-${String(
          date.getMonth() + 1
        ).padStart(2, "0")}`;

        // Calculate revenue total for this month
        const revenueTotal = budgetWorksheet.value.revenue.reduce(
          (sum, item) => {
            return sum + (item.monthlyValues?.[monthKey] || 0);
          },
          0
        );

        // Calculate expenses total for this month
        const expensesTotal = budgetWorksheet.value.expenses.reduce(
          (sum, item) => {
            return sum + (item.monthlyValues?.[monthKey] || 0);
          },
          0
        );

        // Calculate net income
        const netIncome = revenueTotal - expensesTotal;

        totals[monthKey] = {
          revenue: revenueTotal,
          expenses: expensesTotal,
          net: netIncome,
        };
      }

      return totals;
    });

    // LEGACY: Keep for backward compatibility
    const currentDate = new Date();
    const currentYear = currentDate.getFullYear();
    const currentMonth = String(currentDate.getMonth() + 1).padStart(2, "0");
    const currentPeriod = ref(`${currentYear}-${currentMonth}`);

    const currentBudget = computed(() => {
      return (
        budgetLines.value[currentPeriod.value] || {
          period: currentPeriod.value,
          revenueByStream: {},
          payrollCosts: { memberHours: [], oncostApplied: 0 },
          overheadCosts: [],
          productionCosts: [],
          savingsChange: 0,
          net: 0,
        }
      );
    });

    // Actions
    function setBudgetLine(period, budgetData) {
      budgetLines.value[period] = {
        period,
        ...budgetData,
      };
    }

    function updateRevenue(period, streamId, type, amount) {
      if (!budgetLines.value[period]) {
        budgetLines.value[period] = { period, revenueByStream: {} };
      }
      if (!budgetLines.value[period].revenueByStream[streamId]) {
        budgetLines.value[period].revenueByStream[streamId] = {};
      }
      budgetLines.value[period].revenueByStream[streamId][type] = amount;
    }

    // Wizard-required actions
    function addOverheadLine(cost) {
      // Allow creating a blank line so the user can fill it out in the UI
      const safeName = cost?.name ?? "";
      const safeAmountMonthly =
        typeof cost?.amountMonthly === "number" &&
        !Number.isNaN(cost.amountMonthly)
          ? cost.amountMonthly
          : 0;

      overheadCosts.value.push({
        id: Date.now().toString(),
        name: safeName,
        amount: safeAmountMonthly,
        category: cost?.category || "Operations",
        recurring: cost?.recurring ?? true,
        ...cost,
      });
    }

    function removeOverheadLine(id) {
      const index = overheadCosts.value.findIndex((c) => c.id === id);
      if (index > -1) {
        overheadCosts.value.splice(index, 1);
      }
    }

    function addOverheadCost(cost) {
      addOverheadLine({ name: cost.name, amountMonthly: cost.amount, ...cost });
    }

    function addProductionCost(cost) {
      productionCosts.value.push({
        id: Date.now().toString(),
        name: cost.name,
        amount: cost.amount,
        category: cost.category || "Production",
        period: cost.period,
        ...cost,
      });
    }

    function setCurrentPeriod(period) {
      currentPeriod.value = period;
    }

    // Initialize worksheet from wizard data
    async function initializeFromWizardData() {
      if (isInitialized.value && budgetWorksheet.value.revenue.length > 0) {
        console.log("Already initialized with data, skipping...");
        return;
      }

      console.log("Initializing budget from wizard data...");

      // Import stores dynamically to avoid circular deps
      const { useStreamsStore } = await import("./streams");
      const { useMembersStore } = await import("./members");
      const { usePoliciesStore } = await import("./policies");

      const streamsStore = useStreamsStore();
      const membersStore = useMembersStore();
      const policiesStore = usePoliciesStore();

      console.log("Streams:", streamsStore.streams.length, "streams");
      console.log("Members capacity:", membersStore.capacityTotals);
      console.log("Policies wage:", policiesStore.equalHourlyWage);

      // Clear existing data
      budgetWorksheet.value.revenue = [];
      budgetWorksheet.value.expenses = [];

      // Add revenue streams from wizard
      if (streamsStore.streams.length === 0) {
        console.log("No wizard streams found, adding sample data");
        // Initialize with minimal demo if no wizard data exists
        await streamsStore.initializeWithFixtures();
      }

      streamsStore.streams.forEach((stream) => {
        const monthlyAmount = stream.targetMonthlyAmount || 0;
        console.log(
          "Adding stream:",
          stream.name,
          "category:",
          stream.category,
          "subcategory:",
          stream.subcategory,
          "amount:",
          monthlyAmount
        );
        console.log("Full stream object:", stream);

        // Simple category mapping - just map the key categories we know exist
        let mappedCategory = "Games & Products"; // Default
        const categoryLower = (stream.category || "").toLowerCase();
        if (categoryLower === "games" || categoryLower === "product")
          mappedCategory = "Games & Products";
        else if (categoryLower === "services" || categoryLower === "service")
          mappedCategory = "Services & Contracts";
        else if (categoryLower === "grants" || categoryLower === "grant")
          mappedCategory = "Grants & Funding";
        else if (categoryLower === "community")
          mappedCategory = "Community Support";
        else if (
          categoryLower === "partnerships" ||
          categoryLower === "partnership"
        )
          mappedCategory = "Partnerships";
        else if (categoryLower === "investment")
          mappedCategory = "Investment Income";

        console.log(
          "Mapped category from",
          stream.category,
          "to",
          mappedCategory
        );

        // Create monthly values - split the annual target evenly across 12 months
        const monthlyValues = {};
        const today = new Date();
        for (let i = 0; i < 12; i++) {
          const date = new Date(today.getFullYear(), today.getMonth() + i, 1);
          const monthKey = `${date.getFullYear()}-${String(
            date.getMonth() + 1
          ).padStart(2, "0")}`;
          monthlyValues[monthKey] = monthlyAmount;
        }
        console.log(
          "Created monthly values for",
          stream.name,
          ":",
          monthlyValues
        );

        budgetWorksheet.value.revenue.push({
          id: `revenue-${stream.id}`,
          name: stream.name,
          mainCategory: mappedCategory,
          subcategory: stream.subcategory || "Direct sales", // Use actual subcategory from stream
          source: "wizard",
          monthlyValues,
          values: {
            year1: {
              best: monthlyAmount * 12,
              worst: monthlyAmount * 6,
              mostLikely: monthlyAmount * 10,
            },
            year2: {
              best: monthlyAmount * 15,
              worst: monthlyAmount * 8,
              mostLikely: monthlyAmount * 12,
            },
            year3: {
              best: monthlyAmount * 18,
              worst: monthlyAmount * 10,
              mostLikely: monthlyAmount * 15,
            },
          },
        });
      });

      // Add payroll from wizard data
      const totalHours = membersStore.capacityTotals.targetHours || 0;
      const hourlyWage = policiesStore.equalHourlyWage || 0;
      const oncostPct = policiesStore.payrollOncostPct || 0;
      if (totalHours > 0 && hourlyWage > 0) {
        const monthlyPayroll = totalHours * hourlyWage * (1 + oncostPct / 100);

        // Create monthly values for payroll
        const monthlyValues = {};
        const today = new Date();
        for (let i = 0; i < 12; i++) {
          const date = new Date(today.getFullYear(), today.getMonth() + i, 1);
          const monthKey = `${date.getFullYear()}-${String(
            date.getMonth() + 1
          ).padStart(2, "0")}`;
          monthlyValues[monthKey] = monthlyPayroll;
        }

        budgetWorksheet.value.expenses.push({
          id: "expense-payroll",
          name: "Payroll",
          mainCategory: "Salaries & Benefits",
          subcategory: "Base wages and benefits",
          source: "wizard",
          monthlyValues,
          values: {
            year1: {
              best: monthlyPayroll * 12,
              worst: monthlyPayroll * 8,
              mostLikely: monthlyPayroll * 12,
            },
            year2: {
              best: monthlyPayroll * 14,
              worst: monthlyPayroll * 10,
              mostLikely: monthlyPayroll * 13,
            },
            year3: {
              best: monthlyPayroll * 16,
              worst: monthlyPayroll * 12,
              mostLikely: monthlyPayroll * 15,
            },
          },
        });
      }

      // Add overhead costs from wizard
      overheadCosts.value.forEach((cost) => {
        if (cost.amount > 0) {
          const annualAmount = cost.amount * 12;
          // Map overhead cost categories to expense categories
          let expenseCategory = "Other Expenses"; // Default
          if (cost.category === "Operations")
            expenseCategory = "Office & Operations";
          else if (cost.category === "Technology")
            expenseCategory = "Equipment & Technology";
          else if (cost.category === "Legal")
            expenseCategory = "Legal & Professional";
          else if (cost.category === "Marketing")
            expenseCategory = "Marketing & Outreach";

          // Create monthly values for overhead costs
          const monthlyValues = {};
          const today = new Date();
          for (let i = 0; i < 12; i++) {
            const date = new Date(today.getFullYear(), today.getMonth() + i, 1);
            const monthKey = `${date.getFullYear()}-${String(
              date.getMonth() + 1
            ).padStart(2, "0")}`;
            monthlyValues[monthKey] = cost.amount;
          }

          budgetWorksheet.value.expenses.push({
            id: `expense-${cost.id}`,
            name: cost.name,
            mainCategory: expenseCategory,
            subcategory: cost.name, // Use the cost name as subcategory
            source: "wizard",
            monthlyValues,
            values: {
              year1: {
                best: annualAmount,
                worst: annualAmount * 0.8,
                mostLikely: annualAmount,
              },
              year2: {
                best: annualAmount * 1.1,
                worst: annualAmount * 0.9,
                mostLikely: annualAmount * 1.05,
              },
              year3: {
                best: annualAmount * 1.2,
                worst: annualAmount,
                mostLikely: annualAmount * 1.1,
              },
            },
          });
        }
      });

      // Add production costs from wizard
      productionCosts.value.forEach((cost) => {
        if (cost.amount > 0) {
          const annualAmount = cost.amount * 12;
          // Create monthly values for production costs
          const monthlyValues = {};
          const today = new Date();
          for (let i = 0; i < 12; i++) {
            const date = new Date(today.getFullYear(), today.getMonth() + i, 1);
            const monthKey = `${date.getFullYear()}-${String(
              date.getMonth() + 1
            ).padStart(2, "0")}`;
            monthlyValues[monthKey] = cost.amount;
          }

          budgetWorksheet.value.expenses.push({
            id: `expense-${cost.id}`,
            name: cost.name,
            mainCategory: "Development Costs",
            subcategory: cost.name, // Use the cost name as subcategory
            source: "wizard",
            monthlyValues,
            values: {
              year1: {
                best: annualAmount,
                worst: annualAmount * 0.7,
                mostLikely: annualAmount * 0.9,
              },
              year2: {
                best: annualAmount * 1.2,
                worst: annualAmount * 0.8,
                mostLikely: annualAmount,
              },
              year3: {
                best: annualAmount * 1.3,
                worst: annualAmount * 0.9,
                mostLikely: annualAmount * 1.1,
              },
            },
          });
        }
      });

      // If still no data after initialization, add a sample row
      if (budgetWorksheet.value.revenue.length === 0) {
        console.log("Adding sample revenue line");
        // Create monthly values for sample revenue
        const monthlyValues = {};
        const today = new Date();
        for (let i = 0; i < 12; i++) {
          const date = new Date(today.getFullYear(), today.getMonth() + i, 1);
          const monthKey = `${date.getFullYear()}-${String(
            date.getMonth() + 1
          ).padStart(2, "0")}`;
          monthlyValues[monthKey] = 667; // ~8000/12
        }

        budgetWorksheet.value.revenue.push({
          id: "revenue-sample",
          name: "Sample Revenue",
          mainCategory: "Games & Products",
          subcategory: "Direct sales",
          source: "user",
          monthlyValues,
          values: {
            year1: { best: 10000, worst: 5000, mostLikely: 8000 },
            year2: { best: 12000, worst: 6000, mostLikely: 10000 },
            year3: { best: 15000, worst: 8000, mostLikely: 12000 },
          },
        });
      }

      if (budgetWorksheet.value.expenses.length === 0) {
        console.log("Adding sample expense line");
        // Create monthly values for sample expense
        const monthlyValues = {};
        const today = new Date();
        for (let i = 0; i < 12; i++) {
          const date = new Date(today.getFullYear(), today.getMonth() + i, 1);
          const monthKey = `${date.getFullYear()}-${String(
            date.getMonth() + 1
          ).padStart(2, "0")}`;
          monthlyValues[monthKey] = 67; // ~800/12
        }

        budgetWorksheet.value.expenses.push({
          id: "expense-sample",
          name: "Sample Expense",
          mainCategory: "Other Expenses",
          subcategory: "Miscellaneous",
          source: "user",
          monthlyValues,
          values: {
            year1: { best: 1000, worst: 500, mostLikely: 800 },
            year2: { best: 1200, worst: 600, mostLikely: 1000 },
            year3: { best: 1500, worst: 800, mostLikely: 1200 },
          },
        });
      }

      // Debug: Log all revenue items and their categories
      console.log("Final revenue items:");
      budgetWorksheet.value.revenue.forEach((item) => {
        console.log(
          `- ${item.name}: ${item.mainCategory} > ${item.subcategory} (${item.values.year1.mostLikely})`
        );
      });

      console.log("Final expense items:");
      budgetWorksheet.value.expenses.forEach((item) => {
        console.log(
          `- ${item.name}: ${item.mainCategory} > ${item.subcategory} (${item.values.year1.mostLikely})`
        );
      });

      // Ensure all items have monthlyValues and new structure - migrate existing items
      [
        ...budgetWorksheet.value.revenue,
        ...budgetWorksheet.value.expenses,
      ].forEach((item) => {
        // Migrate to new structure if needed
        if (item.category && !item.mainCategory) {
          console.log("Migrating item structure for:", item.name);
          item.mainCategory = item.category; // Old category becomes mainCategory

          // Set appropriate subcategory based on the main category and item name
          if (item.category === "Games & Products") {
            const gameSubcategories = [
              "Direct sales",
              "Platform revenue share",
              "DLC/expansions",
              "Merchandise",
            ];
            item.subcategory = gameSubcategories.includes(item.name)
              ? item.name
              : "Direct sales";
          } else if (item.category === "Services & Contracts") {
            const serviceSubcategories = [
              "Contract development",
              "Consulting",
              "Workshops/teaching",
              "Technical services",
            ];
            item.subcategory = serviceSubcategories.includes(item.name)
              ? item.name
              : "Contract development";
          } else if (item.category === "Investment Income") {
            const investmentSubcategories = [
              "Impact investment",
              "Venture capital",
              "Loans",
            ];
            item.subcategory = investmentSubcategories.includes(item.name)
              ? item.name
              : "Impact investment";
          } else if (item.category === "Salaries & Benefits") {
            item.subcategory = "Base wages and benefits";
          } else if (item.category === "Office & Operations") {
            // Map specific office tools to appropriate subcategories
            if (
              item.name.toLowerCase().includes("rent") ||
              item.name.toLowerCase().includes("office")
            ) {
              item.subcategory = "Rent";
            } else if (item.name.toLowerCase().includes("util")) {
              item.subcategory = "Utilities";
            } else if (item.name.toLowerCase().includes("insurance")) {
              item.subcategory = "Insurance";
            } else {
              item.subcategory = "Office supplies";
            }
          } else {
            // For other categories, use appropriate default
            item.subcategory = "Miscellaneous";
          }

          delete item.category; // Remove old property
        }

        if (!item.monthlyValues) {
          console.log("Migrating item to monthly values:", item.name);
          item.monthlyValues = {};
          const today = new Date();
          for (let i = 0; i < 12; i++) {
            const date = new Date(today.getFullYear(), today.getMonth() + i, 1);
            const monthKey = `${date.getFullYear()}-${String(
              date.getMonth() + 1
            ).padStart(2, "0")}`;
            // Try to use most likely value divided by 12, or default to 0
            const yearlyValue = item.values?.year1?.mostLikely || 0;
            item.monthlyValues[monthKey] = Math.round(yearlyValue / 12);
          }
          console.log(
            "Added monthly values to",
            item.name,
            ":",
            item.monthlyValues
          );
        }
      });

      console.log(
        "Initialization complete. Revenue items:",
        budgetWorksheet.value.revenue.length,
        "Expense items:",
        budgetWorksheet.value.expenses.length
      );

      isInitialized.value = true;
    }

    // NEW: Budget worksheet functions
    function updateBudgetValue(category, itemId, year, scenario, value) {
      const items = budgetWorksheet.value[category];
      const item = items.find((i) => i.id === itemId);
      if (item) {
        item.values[year][scenario] = Number(value) || 0;
      }
    }

    function updateMonthlyValue(category, itemId, monthKey, value) {
      const items = budgetWorksheet.value[category];
      const item = items.find((i) => i.id === itemId);
      if (item) {
        if (!item.monthlyValues) {
          item.monthlyValues = {};
        }
        item.monthlyValues[monthKey] = Number(value) || 0;
      }
    }

    function addBudgetItem(category, name, selectedCategory = "") {
      const id = `${category}-${Date.now()}`;

      // Create empty monthly values for next 12 months
      const monthlyValues = {};
      const today = new Date();
      for (let i = 0; i < 12; i++) {
        const date = new Date(today.getFullYear(), today.getMonth() + i, 1);
        const monthKey = `${date.getFullYear()}-${String(
          date.getMonth() + 1
        ).padStart(2, "0")}`;
        monthlyValues[monthKey] = 0;
      }

      const newItem = {
        id,
        name,
        mainCategory:
          selectedCategory ||
          (category === "revenue" ? "Games & Products" : "Other Expenses"),
        subcategory: "", // Will be set by user via dropdown
        source: "user",
        monthlyValues,
        values: {
          year1: { best: 0, worst: 0, mostLikely: 0 },
          year2: { best: 0, worst: 0, mostLikely: 0 },
          year3: { best: 0, worst: 0, mostLikely: 0 },
        },
      };
      budgetWorksheet.value[category].push(newItem);
      return id;
    }

    function removeBudgetItem(category, itemId) {
      const items = budgetWorksheet.value[category];
      const index = items.findIndex((i) => i.id === itemId);
      if (index > -1) {
        items.splice(index, 1);
      }
    }

    function renameBudgetItem(category, itemId, newName) {
      const items = budgetWorksheet.value[category];
      const item = items.find((i) => i.id === itemId);
      if (item) {
        item.name = newName;
      }
    }

    function updateBudgetCategory(category, itemId, newCategory) {
      const items = budgetWorksheet.value[category];
      const item = items.find((i) => i.id === itemId);
      if (item) {
        item.category = newCategory;
      }
    }

    function addCustomCategory(type, categoryName) {
      if (
        type === "revenue" &&
        !revenueCategories.value.includes(categoryName)
      ) {
        revenueCategories.value.push(categoryName);
      } else if (
        type === "expenses" &&
        !expenseCategories.value.includes(categoryName)
      ) {
        expenseCategories.value.push(categoryName);
      }
    }

    // Reset function
    function resetBudgetOverhead() {
      overheadCosts.value = [];
      productionCosts.value = [];
    }

    function resetBudgetWorksheet() {
      // Reset all values to 0 but keep the structure
      [
        ...budgetWorksheet.value.revenue,
        ...budgetWorksheet.value.expenses,
      ].forEach((item) => {
        Object.keys(item.values).forEach((year) => {
          Object.keys(item.values[year]).forEach((scenario) => {
            item.values[year][scenario] = 0;
          });
        });
      });
    }

    return {
      // NEW: Budget worksheet
      budgetWorksheet,
      budgetTotals,
      monthlyTotals,
      revenueCategories,
      expenseCategories,
      revenueSubcategories,
      groupedRevenue,
      groupedExpenses,
      isInitialized,
      initializeFromWizardData,
      updateBudgetValue,
      updateMonthlyValue,
      addBudgetItem,
      removeBudgetItem,
      renameBudgetItem,
      updateBudgetCategory,
      addCustomCategory,
      resetBudgetWorksheet,
      // LEGACY: Keep for backward compatibility
      budgetLines,
      overheadCosts,
      productionCosts,
      currentPeriod: readonly(currentPeriod),
      currentBudget,
      schemaVersion,
      setBudgetLine,
      updateRevenue,
      // Wizard actions
      addOverheadLine,
      removeOverheadLine,
      resetBudgetOverhead,
      // Legacy actions
      addOverheadCost,
      addProductionCost,
      setCurrentPeriod,
    };
  },
  {
    persist: {
      key: "urgent-tools-budget",
      paths: [
        "budgetWorksheet",
        "revenueCategories",
        "expenseCategories",
        "isInitialized",
        "overheadCosts",
        "productionCosts",
        "currentPeriod",
      ],
    },
  }
);