package http

import (
	"fmt"
	"net/http"
	"strconv"
	"time"

	"git.javil.eu/jacob1123/budgeteer/postgres"
	"github.com/gin-gonic/gin"
	"github.com/google/uuid"
)

type BudgetingData struct {
	AlwaysNeededData
	Categories       []postgres.GetCategoriesWithBalanceRow
	AvailableBalance postgres.Numeric
	Date             time.Time
	Next             time.Time
	Previous         time.Time
}

func getFirstOfMonth(year, month int, location *time.Location) time.Time {
	return time.Date(year, time.Month(month), 1, 0, 0, 0, 0, location)
}

func getFirstOfMonthTime(date time.Time) time.Time {
	var monthM time.Month
	year, monthM, _ := date.Date()
	month := int(monthM)
	return getFirstOfMonth(year, month, date.Location())
}

func (h *Handler) budgeting(c *gin.Context) {
	budgetID := c.Param("budgetid")
	budgetUUID, err := uuid.Parse(budgetID)
	if err != nil {
		c.Redirect(http.StatusTemporaryRedirect, "/login")
		return
	}

	var firstOfMonth time.Time
	var year, month int
	yearString := c.Param("year")
	monthString := c.Param("month")
	if yearString != "" && monthString != "" {
		year, err = strconv.Atoi(yearString)
		if err != nil {
			c.Redirect(http.StatusTemporaryRedirect, "/budget/"+budgetUUID.String())
			return
		}

		month, err = strconv.Atoi(monthString)
		if err != nil {
			c.Redirect(http.StatusTemporaryRedirect, "/budget/"+budgetUUID.String())
			return
		}

		firstOfMonth = getFirstOfMonth(year, month, time.Now().Location())
	} else {
		firstOfMonth = getFirstOfMonthTime(time.Now())
	}

	firstOfNextMonth := firstOfMonth.AddDate(0, 1, 0)
	firstOfPreviousMonth := firstOfMonth.AddDate(0, -1, 0)

	params := postgres.GetCategoriesWithBalanceParams{
		BudgetID:     budgetUUID,
		FromDate:     firstOfMonth,
		ToDate:       firstOfNextMonth,
		PrevFromDate: firstOfMonth.AddDate(0, -1, 0),
	}
	categories, err := h.Service.DB.GetCategoriesWithBalance(c.Request.Context(), params)
	if err != nil {
		c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("load categories: %w", err))
		return
	}

	cumultativeBalances, err := h.Service.DB.GetCumultativeBalances(c.Request.Context(), budgetUUID)
	if err != nil {
		c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("load balances: %w", err))
		return
	}

	var available float64 = 0
	var added float64 = 0
	var assigned float64 = 0
	for i := range categories {
		cat := &categories[i]
		var balance float64 = 0
		for _, bal := range cumultativeBalances {
			if bal.CategoryID != cat.ID {
				continue
			}

			// skip everything in the future
			if !bal.Date.Before(firstOfNextMonth) {
				continue
			}

			assigned += bal.Assignments.GetFloat64()
			balance += bal.Assignments.GetFloat64()
			balance += bal.Transactions.GetFloat64()
			if balance < 0 && bal.Date.Before(firstOfMonth) {
				added -= balance
				balance = 0
			}

			if bal.Date.Before(firstOfMonth) {
				available = balance
			}
		}

		num := postgres.Numeric{}
		num.Set(balance)
		cat.Available = num

		num2 := postgres.Numeric{}
		num2.Set(available)
		cat.AvailableLastMonth = num2
	}

	data := c.MustGet("data").(AlwaysNeededData)
	var availableBalance float64 = 0
	for _, cat := range categories {
		if cat.ID != data.Budget.IncomeCategoryID {
			continue
		}
		availableBalance = -assigned - added

		for _, bal := range cumultativeBalances {
			if bal.CategoryID != cat.ID {
				continue
			}

			if !bal.Date.Before(firstOfNextMonth) {
				continue
			}

			availableBalance += bal.Transactions.GetFloat64()
		}
	}

	var availableBalanceNum postgres.Numeric
	availableBalanceNum.Set(availableBalance)

	d := BudgetingData{
		c.MustGet("data").(AlwaysNeededData),
		categories,
		availableBalanceNum,
		firstOfMonth,
		firstOfNextMonth,
		firstOfPreviousMonth,
	}

	c.HTML(http.StatusOK, "budgeting.html", d)
}