package ui

import (
	"fmt"
	"log"
	"os"
	"slices"
	"sort"
	"strings"

	"github.com/gotk3/gotk3/gtk"
	"varia.zone/hui/internal/bldr"
	"varia.zone/hui/internal/conf"
	"varia.zone/hui/internal/model"
)

// SetHeaderBarSubtitle sets the header bar subtitle.
func SetHeaderBarSubtitle(m *model.Model, siteName string) error {
	headerBar, err := bldr.GetHeaderBar(m.Builder, conf.HeaderBar)
	if err != nil {
		return fmt.Errorf("SetHeaderBarSubtitle: unable to retrieve '%s': %s", conf.HeaderBar, err)
	}

	headerBar.SetSubtitle(siteName)

	return nil
}

// getSiteButtons retrieves the site related header bar buttons.
func getSiteButtons(m *model.Model) (*gtk.Box, *gtk.Button, error) {
	box, err := bldr.GetBox(m.Builder, conf.OpenSiteBox)
	if err != nil {
		return nil, nil, err
	}

	btn, err := bldr.GetButton(m.Builder, conf.CreateSiteButton)
	if err != nil {
		return nil, nil, err
	}

	return box, btn, nil
}

// ShowSiteButtons shows site related buttons.
func ShowSiteButtons(m *model.Model) error {
	box, btn, err := getSiteButtons(m)
	if err != nil {
		return fmt.Errorf("ShowSiteButtons: %s", err)
	}

	box.Show()
	btn.Show()

	return nil
}

// HideSiteButtons shows site related buttons.
func HideSiteButtons(m *model.Model) error {
	box, btn, err := getSiteButtons(m)
	if err != nil {
		return fmt.Errorf("HideSiteButtons: %s", err)
	}

	box.Hide()
	btn.Hide()

	return nil
}

func getContentButtons(m *model.Model) (*gtk.Separator, []*gtk.Button, error) {
	sep, err := bldr.GetSeparator(m.Builder, conf.HeaderBarSeparator)
	if err != nil {
		return nil, nil, err
	}

	var btns []*gtk.Button
	for _, name := range []string{conf.CreatePostButton, conf.PreviewButton} {
		btn, err := bldr.GetButton(m.Builder, name)
		if err != nil {
			return nil, nil, err
		}
		btns = append(btns, btn)
	}

	return sep, btns, err
}

// ShowContentButtons shows content related buttons.
func ShowContentButtons(m *model.Model) error {
	sep, btns, err := getContentButtons(m)
	if err != nil {
		return fmt.Errorf("HideContentButtons: %s", err)
	}

	sep.Show()

	for _, btn := range btns {
		btn.Show()
	}

	return nil
}

// HideContentButtons shows content related buttons.
func HideContentButtons(m *model.Model) error {
	sep, btns, err := getContentButtons(m)
	if err != nil {
		return fmt.Errorf("HideContentButtons: %s", err)
	}

	sep.Hide()

	for _, btn := range btns {
		btn.Hide()
	}

	return nil
}

// OpenMenuChoice responds to a clicked "existing menu" selection.
func OpenMenuChoice(m *model.Model, menuItem *gtk.MenuItem) error {
	label := menuItem.GetLabel()
	splitLabel := strings.Split(label, " ")
	siteName := strings.TrimSpace(splitLabel[len(splitLabel)-1])

	m.CurrentSite = siteName

	if err := SetHeaderBarSubtitle(m, m.CurrentSite); err != nil {
		return fmt.Errorf("OpenMenuChoice: unable to set header bar subtitle: %s", err)
	}

	return nil
}

// gatherSiteNames gathers the site names from disk.
func gatherSiteNames(m *model.Model) error {
	sitesDir := conf.SitesDir(m.User.HomeDir)

	entries, err := os.ReadDir(sitesDir)
	if err != nil {
		return fmt.Errorf("gatherSiteNames: unable to read '%s'", sitesDir)
	}

	for _, entry := range entries {
		siteName := entry.Name()
		if !slices.Contains(m.SiteNames, siteName) {
			m.SiteNames = append(m.SiteNames, siteName)
		}
	}

	sort.Strings(m.SiteNames)

	return err
}

// PopulateOpenSiteMenu populates the open site menu with site names.
func PopulateOpenSiteMenu(m *model.Model) error {
	menu, err := bldr.GetMenu(m.Builder, conf.OpenSiteMenu)
	if err != nil {
		return err
	}

	var forEachErr error
	menu.GetChildren().Foreach(func(o interface{}) {
		menuItem, ok := o.(*gtk.Widget)
		if !ok {
			forEachErr = fmt.Errorf("PopulateOpenSiteMenu: unable to retrieve MenuItem")
			return
		}
		menu.Remove(menuItem)
	})
	if forEachErr != nil {
		return err
	}

	if err := gatherSiteNames(m); err != nil {
		return err
	}

	for idx, siteName := range m.SiteNames {
		menuItem, err := gtk.MenuItemNew()
		if err != nil {
			return err
		}

		menuItem.SetLabel(fmt.Sprintf("%d. %s", idx, siteName))
		menuItem.ShowAll()

		menu.Append(menuItem)

		menuItem.Connect("activate", func() {
			if err := OpenMenuChoice(m, menuItem); err != nil {
				if err := ShowErrDialog(m, err); err != nil {
					log.Fatal(fmt.Errorf("PopulateOpenSiteMenu: unable to show error dialog: %s", err))
				}
			}
		})
	}

	return nil
}