package web

import (
	"nickiel.net/recount_server/db"
	"nickiel.net/recount_server/web/templates"

	"html/template"
	"net/http"
	"strconv"

	"bytes"
	"context"

	"github.com/a-h/templ"
	"github.com/go-chi/chi/v5"
	"github.com/rs/zerolog"
	"github.com/rs/zerolog/log"
)

type IndexTemplateModel struct {
    InnerHtml template.HTML
    ActivePage string
    NewTransactionPane template.HTML
    QuickAccessPane template.HTML
}

const TemplateDir = "./web/templates/"

func SetLogLevel(level zerolog.Level) {
	zerolog.SetGlobalLevel(level)
}

func WebRouter() http.Handler {
	r := chi.NewRouter()
	r.Get("/", getDashboard)
    r.Get("/transactions", getTransactionsPage)

    r.Get("/components/account_summaries", GetAccountSummaries)

    r.Get("/components/data/transaction_table_rows", GetTransactionsRows)
    r.Get("/components/data/expenditure_chart", GetExpenditureChart)
    r.Get("/components/data/account_summary/{accountID}", GetAccountSummaryChart)
    r.Get("/components/data/transaction_quick_access", GetTransactionQuickAccessEntries)

    r.Handle("/static/*", http.StripPrefix("/static/", http.FileServer(http.Dir("web/static/"))))
	return r
}

//for name, values := range req.Header {
    // Loop over all values for the name.
//    for _, value := range values {
//        log.Debug().Msg(name + " " + value);
//    }
// }

func renderFullPage(w http.ResponseWriter, c templ.Component, pageName string) {
    var main_component bytes.Buffer

    // Render the provided templ component
    err := c.Render(context.Background(), &main_component)
    if err != nil {
        log.Fatal().Err(err).Msg("Fatal error reading hello template");
    }

    // get the index template
    index, err := template.ParseFiles(TemplateDir + "index.html")
    if err != nil {
        log.Fatal().
            Err(err).
            Msg("Fatal error reading index template")
    }


    var new_tp bytes.Buffer;

    quick_trans_types, err := db.GetTransPaneEntries(0);

    err = templates.NewTransactionPane(&quick_trans_types).Render(context.Background(), &new_tp);
    if err != nil {
        log.Fatal().Err(err).Msg("Could not render new transaction pane for index");
    }

    var quick_ap bytes.Buffer;
    err = templates.QuickAccessPane().Render(context.Background(), &quick_ap);
    if err != nil {
        log.Fatal().Err(err).Msg("Could not render quick access pane for index");
    }
    
    // Inject the templ component html into the index template
    err = index.Execute(w, 
        IndexTemplateModel{
            InnerHtml: template.HTML(main_component.String()),
            ActivePage: pageName,
            NewTransactionPane: template.HTML(new_tp.String()),
            QuickAccessPane: template.HTML(quick_ap.String()),
        });
    if err != nil {
        log.Fatal().Err(err).Msg("Fatal error reading hello template");
    }
}

func getDashboard(w http.ResponseWriter, req *http.Request) {
    component := templates.Dashboard();

    _, ok := req.Header["Hx-Request"]
    if ok {
        err := component.Render(context.Background(), w);          
        if err != nil {
            log.Fatal().Err(err).Msg("Couldn't render dashboard templ template");
        }
    } else {
        renderFullPage(w, component, "Dashboard");
    }
}

func getTransactionsPage(w http.ResponseWriter, req *http.Request) {
    accounts := make([]string, 10);
    for i := 0; i < 10; i++ {
        accounts[i] = strconv.Itoa(i) + " Account";
    }

    component := templates.TransactionsPage(1, &accounts);
    _, ok := req.Header["Hx-Request"]
    if ok {
        err := component.Render(context.Background(), w);
        if err != nil {
            log.Fatal().Err(err).Msg("Couldn't render transactions templ template");
        }
    } else {
        renderFullPage(w, component, "Transactions")
    }
}