package app

import (
	"encoding/json"
	"fmt"
	"slices"
	"sort"
	"strings"

	"coopcloud.tech/abra/cli/internal"
	appPkg "coopcloud.tech/abra/pkg/app"
	"coopcloud.tech/abra/pkg/autocomplete"
	"coopcloud.tech/abra/pkg/i18n"
	"coopcloud.tech/abra/pkg/log"
	"coopcloud.tech/abra/pkg/recipe"
	"coopcloud.tech/tagcmp"
	"github.com/charmbracelet/bubbles/key"
	"github.com/charmbracelet/bubbles/spinner"
	tea "github.com/charmbracelet/bubbletea"
	"github.com/charmbracelet/lipgloss"
	"github.com/evertras/bubble-table/table"
	"github.com/spf13/cobra"
)

type appStatus struct {
	Server       string `json:"server"`
	Recipe       string `json:"recipe"`
	AppName      string `json:"appName"`
	Domain       string `json:"domain"`
	Status       string `json:"status"`
	Chaos        string `json:"chaos"`
	ChaosVersion string `json:"chaosVersion"`
	AutoUpdate   string `json:"autoUpdate"`
	Version      string `json:"version"`
	Upgrade      string `json:"upgrade"`
}

type serverStatus struct {
	Apps             []appStatus `json:"apps"`
	AppCount         int         `json:"appCount"`
	VersionCount     int         `json:"versionCount"`
	UnversionedCount int         `json:"unversionedCount"`
	LatestCount      int         `json:"latestCount"`
	UpgradeCount     int         `json:"upgradeCount"`
}

// translators: `abra app list` aliases. use a comma separated list of aliases with
// no spaces in between
var appListAliases = i18n.G("ls")

var AppListCommand = &cobra.Command{
	// translators: `app list` command
	Use:     i18n.G("list [flags]"),
	Aliases: strings.Split(appListAliases, ","),
	// translators: Short description for `app list` command
	Short: i18n.G("List all managed apps"),
	Long: i18n.G(`Generate a report of all managed apps.

Use "--status/-S" flag to query all servers for the live deployment status.`),
	Example: i18n.G(`  # list apps of all servers without live status
  abra app ls

  # list apps of a specific server with live status
  abra app ls -s 1312.net -S

  # list apps of all servers which match a specific recipe
  abra app ls -r gitea`),
	Args: cobra.NoArgs,
	Run: func(cmd *cobra.Command, args []string) {
		appFiles, err := appPkg.LoadAppFiles(listAppServer)
		if err != nil {
			log.Fatal(err)
		}

		apps, err := appPkg.GetApps(appFiles, recipeFilter)
		if err != nil {
			log.Fatal(err)
		}

		sort.Sort(appPkg.ByServerAndRecipe(apps))

		statuses := make(map[string]map[string]string)
		if status && internal.MachineReadable {
			alreadySeen := make(map[string]bool)
			for _, app := range apps {
				if _, ok := alreadySeen[app.Server]; !ok {
					alreadySeen[app.Server] = true
				}
			}

			statuses, err = appPkg.GetAppStatuses(apps, internal.MachineReadable)
			if err != nil {
				log.Fatal(err)
			}
		}

		var totalServersCount int
		var totalAppsCount int
		allStats := make(map[string]serverStatus)
		for _, app := range apps {
			var stats serverStatus
			var ok bool
			if stats, ok = allStats[app.Server]; !ok {
				stats = serverStatus{}
				if recipeFilter == "" {
					// count server, no filtering
					totalServersCount++
				}
			}

			if app.Recipe.Name == recipeFilter || recipeFilter == "" {
				if recipeFilter != "" {
					// only count server if matches filter
					totalServersCount++
				}

				appStats := appStatus{}
				stats.AppCount++
				totalAppsCount++

				if status && internal.MachineReadable {
					status := i18n.G("unknown")
					version := i18n.G("unknown")
					chaos := i18n.G("unknown")
					chaosVersion := i18n.G("unknown")
					autoUpdate := i18n.G("unknown")
					if statusMeta, ok := statuses[app.StackName()]; ok {
						if currentVersion, exists := statusMeta["version"]; exists {
							if currentVersion != "" {
								version = currentVersion
							}
						}
						if chaosDeploy, exists := statusMeta["chaos"]; exists {
							chaos = chaosDeploy
						}
						if chaosDeployVersion, exists := statusMeta["chaosVersion"]; exists {
							chaosVersion = chaosDeployVersion
						}
						if autoUpdateState, exists := statusMeta["autoUpdate"]; exists {
							autoUpdate = autoUpdateState
						}
						if statusMeta["status"] != "" {
							status = statusMeta["status"]
						}
						stats.VersionCount++
					} else {
						stats.UnversionedCount++
					}

					appStats.Status = status
					appStats.Chaos = chaos
					appStats.ChaosVersion = chaosVersion
					appStats.Version = version
					appStats.AutoUpdate = autoUpdate

					var newUpdates []string
					if version != "unknown" && chaos == "false" {
						if err := app.Recipe.EnsureExists(); err != nil {
							log.Fatal(i18n.G("unable to clone %s: %s", app.Name, err))
						}

						updates, err := app.Recipe.Tags()
						if err != nil {
							log.Fatal(i18n.G("unable to retrieve tags for %s: %s", app.Name, err))
						}

						parsedVersion, err := tagcmp.Parse(version)
						if err != nil {
							log.Fatal(err)
						}

						for _, update := range updates {
							if ok := tagcmp.IsParsable(update); !ok {
								log.Debug(i18n.G("unable to parse %s, skipping as upgrade option", update))
								continue
							}

							parsedUpdate, err := tagcmp.Parse(update)
							if err != nil {
								log.Fatal(err)
							}

							if update != version && parsedUpdate.IsGreaterThan(parsedVersion) {
								newUpdates = append(newUpdates, update)
							}
						}
					}

					if len(newUpdates) == 0 {
						if version == "unknown" {
							appStats.Upgrade = i18n.G("unknown")
						} else {
							appStats.Upgrade = i18n.G("latest")
							stats.LatestCount++
						}
					} else {
						newUpdates = internal.SortVersionsDesc(newUpdates)
						appStats.Upgrade = strings.Join(newUpdates, "\n")
						stats.UpgradeCount++
					}
				}

				appStats.Server = app.Server
				appStats.Recipe = app.Recipe.Name
				appStats.AppName = app.Name
				appStats.Domain = app.Domain

				stats.Apps = append(stats.Apps, appStats)
			}
			allStats[app.Server] = stats
		}

		if internal.MachineReadable {
			jsonstring, err := json.Marshal(allStats)
			if err != nil {
				log.Fatal(err)
			} else {
				fmt.Println(string(jsonstring))
			}

			return
		}

		if err := runTable(apps); err != nil {
			log.Fatal(err)
		}
	},
}

var (
	status        bool
	recipeFilter  string
	listAppServer string
)

func init() {
	AppListCommand.Flags().BoolVarP(
		&status,
		i18n.G("status"),
		i18n.G("S"),
		false,
		i18n.G("show app deployment status"),
	)

	AppListCommand.Flags().StringVarP(
		&recipeFilter,
		i18n.G("recipe"),
		i18n.G("r"),
		"",
		i18n.G("show apps of a specific recipe"),
	)

	AppListCommand.RegisterFlagCompletionFunc(
		i18n.G("recipe"),
		func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
			return autocomplete.RecipeNameComplete()
		},
	)

	AppListCommand.Flags().BoolVarP(
		&internal.MachineReadable,
		i18n.G("machine"),
		i18n.G("m"),
		false,
		i18n.G("print machine-readable output"),
	)

	AppListCommand.Flags().StringVarP(
		&listAppServer,
		i18n.G("server"),
		i18n.G("s"),
		"",
		i18n.G("show apps of a specific server"),
	)

	AppListCommand.RegisterFlagCompletionFunc(
		i18n.G("server"),
		func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
			return autocomplete.ServerNameComplete()
		},
	)
}

func getNumServersAndRecipes(apps []appPkg.App) (int, int) {
	var (
		servers []string
		recipes []string
	)

	for _, app := range apps {
		if !slices.Contains(servers, app.Server) {
			servers = append(servers, app.Server)
		}
		if !slices.Contains(recipes, app.Recipe.Name) {
			recipes = append(recipes, app.Recipe.Name)
		}
	}

	return len(servers), len(recipes)
}

type errorMsg struct{ err error }

func (e errorMsg) Error() string { return e.err.Error() }

type appsDeployStatusMsg map[string]map[string]string

func getAppsDeployStatus(m model) tea.Msg {
	var apps []appPkg.App

	for _, row := range m.table.GetVisibleRows() {
		apps = append(apps, row.Data["app"].(appPkg.App))
	}

	statuses, err := appPkg.GetAppStatuses(apps, true)
	if err != nil {
		return errorMsg{err}
	}

	catl, err := recipe.ReadRecipeCatalogue(true)
	if err != nil {
		return errorMsg{err}
	}

	for _, app := range apps {
		var newUpdates []string
		if status, ok := statuses[app.StackName()]; ok {
			if version, ok := status["version"]; ok {
				updates, err := recipe.GetRecipeCatalogueVersions(app.Recipe.Name, catl)
				if err != nil {
					return errorMsg{err}
				}

				parsedVersion, err := tagcmp.Parse(version)
				if err != nil {
					continue
				}

				for _, update := range updates {
					parsedUpdate, err := tagcmp.Parse(update)
					if err != nil {
						continue
					}

					if update != version && parsedUpdate.IsGreaterThan(parsedVersion) {
						newUpdates = append(newUpdates, update)
					}
				}

				if len(newUpdates) != 0 {
					statuses[app.StackName()]["updates"] = strings.Join(newUpdates, "\n")
				}
			}
		}
	}

	return appsDeployStatusMsg(statuses)
}

func renderAppsDeployStatus(m *model, appStatuses appsDeployStatusMsg) table.Model {
	for _, row := range m.table.GetVisibleRows() {
		app := row.Data["app"].(appPkg.App)
		appStatus := appStatuses[app.StackName()]
		var (
			version      = appStatus["version"]
			updates      = appStatus["updates"]
			status       = appStatus["status"]
			chaos        = appStatus["chaos"]
			chaosVersion = appStatus["chaosVersion"]
			autoUpdate   = appStatus["autoUpdate"]
		)

		if status != "" {
			row.Data["status"] = status
		}

		if version != "" {
			row.Data["version"] = version
			row.Data["updates"] = updates
		}

		if chaos != "" {
			if chaosVersion != "" {
				row.Data["chaos-version"] = chaosVersion
			}
		}

		if autoUpdate != "" {
			row.Data["autoUpdate"] = autoUpdate
		}
	}
	return m.table
}

type initTableMsg struct{ table table.Model }

func initTable(m model) tea.Msg {
	var rows []table.Row

	for _, app := range m.apps {
		rows = append(rows, table.NewRow(table.RowData{
			"domain": app.Domain,
			"server": app.Server,
			"recipe": app.Recipe.Name,
			"app":    app,
		}))
	}

	colStyle := lipgloss.NewStyle().Align(lipgloss.Left)
	columns := []table.Column{
		table.NewFlexColumn("domain", "DOMAIN", 2).WithFiltered(true).WithStyle(colStyle),
		table.NewFlexColumn("server", "SERVER", 1).WithFiltered(true).WithStyle(colStyle),
		table.NewFlexColumn("recipe", "RECIPE", 1).WithFiltered(true).WithStyle(colStyle),
		table.NewFlexColumn("status", "STATUS", 1).WithFiltered(true).WithStyle(colStyle),
		table.NewFlexColumn("version", "VERSION", 1).WithFiltered(true).WithStyle(colStyle),
		table.NewFlexColumn("updates", "UPDATES", 1).WithFiltered(true).WithStyle(colStyle),
		table.NewFlexColumn("chaos-version", "CHAOS", 1).WithFiltered(true).WithStyle(colStyle),
		table.NewFlexColumn("auto-update", "AUTO-UPDATE", 1).WithFiltered(true).WithStyle(colStyle),
	}

	keymap := table.DefaultKeyMap()
	keymap.Filter = key.NewBinding(key.WithKeys("/", "f"))
	keymap.PageDown = key.NewBinding(key.WithKeys("right", "l", "pgdown", "ctrl+d"))
	keymap.PageUp = key.NewBinding(key.WithKeys("left", "h", "pgup", "ctrl+u"))

	t := table.
		New(columns).
		Filtered(true).
		Focused(true).
		WithRows([]table.Row(rows)).
		WithKeyMap(keymap).
		WithMultiline(true).
		WithFuzzyFilter().
		SortByAsc("domain").
		WithNoPagination().
		WithMissingDataIndicatorStyled(table.StyledCell{
			Style: lipgloss.NewStyle().Foreground(lipgloss.Color("#faa")),
			Data:  "-",
		})

	return initTableMsg{table: t}
}

type model struct {
	apps []appPkg.App

	numApps    int
	numServers int
	numRecipes int

	numFilteredApps    int
	numFilteredServers int
	numFilteredRecipes int

	initStatusGather bool

	table         table.Model
	spinner       spinner.Model
	pollingStatus bool

	width  int
	height int

	err error
}

func (m model) getFilteredApps() []appPkg.App {
	var servers []appPkg.App
	for _, row := range m.table.GetVisibleRows() {
		servers = append(servers, row.Data["app"].(appPkg.App))
	}
	return servers
}

func (m *model) updateCount() {
	if m.table.GetIsFilterActive() {
		apps := m.getFilteredApps()
		m.numFilteredApps = len(apps)
		m.numFilteredServers, m.numFilteredRecipes = getNumServersAndRecipes(apps)
	} else {
		m.numFilteredApps = m.numApps
		m.numFilteredServers = m.numServers
		m.numFilteredRecipes = m.numRecipes
	}
}

func (m model) Init() tea.Cmd {
	return tea.Batch(
		func() tea.Msg { return initTable(m) },
		m.spinner.Tick,
	)
}

func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
	var cmd tea.Cmd
	var cmds []tea.Cmd

	switch msg := msg.(type) {
	case tea.KeyMsg:
		m.updateCount()

		switch msg.String() {
		case "q":
			return m, tea.Quit
		case "s":
			if !m.table.GetIsFilterInputFocused() {
				m.pollingStatus = true
				return m, func() tea.Msg { return getAppsDeployStatus(m) }
			}
		}
	case initTableMsg:
		m.table = msg.table

		m.table = m.table.WithTargetWidth(m.width)
		m.table = m.table.WithPageSize(calculateHeight(m))

		if m.initStatusGather {
			m.pollingStatus = true
			return m, func() tea.Msg { return getAppsDeployStatus(m) }
		}
	case appsDeployStatusMsg:
		m.pollingStatus = false
		m.table = renderAppsDeployStatus(&m, msg)
	case tea.WindowSizeMsg:
		m.width = msg.Width
		m.height = msg.Height

		m.table = m.table.WithTargetWidth(m.width)
		m.table = m.table.WithPageSize(calculateHeight(m))
	case errorMsg:
		m.err = msg
	}

	m.table, cmd = m.table.Update(msg)
	cmds = append(cmds, cmd)

	m.spinner, cmd = m.spinner.Update(msg)
	cmds = append(cmds, cmd)

	return m, tea.Batch(cmds...)
}

func calculateHeight(m model) int {
	return m.height/2 - 5
}

func (m model) View() string {
	if m.err != nil {
		return fmt.Sprintf("FATA: %v", m.err)
	}

	body := strings.Builder{}

	body.WriteString(m.table.View() + "\n")

	stats := fmt.Sprintf(
		"[servers] %v • [apps] %v • [recipes] %v",
		m.numFilteredServers, m.numFilteredApps, m.numFilteredRecipes,
	)

	help := "[q] quit • [/] filter • [s] status • [ctrl+u/d] page up/down"

	body.WriteString(lipgloss.JoinHorizontal(lipgloss.Center, stats, " | ", help))

	if m.pollingStatus {
		body.WriteString(fmt.Sprintf(" | %s querying app status", m.spinner.View()))
	} else {
		body.WriteString(" | -")
	}

	return body.String()
}

func runTable(apps []appPkg.App) error {
	s := spinner.New()
	s.Spinner = spinner.Dot
	s.Style = lipgloss.NewStyle().Foreground(lipgloss.Color("205"))

	numServers, numRecipes := getNumServersAndRecipes(apps)
	numApps := len(apps)

	m := model{
		apps:               apps,
		numApps:            numApps,
		numServers:         numServers,
		numRecipes:         numRecipes,
		numFilteredApps:    numApps,
		numFilteredServers: numServers,
		numFilteredRecipes: numRecipes,
		spinner:            s,
		initStatusGather:   status,
	}

	p := tea.NewProgram(m, tea.WithAltScreen())
	if _, err := p.Run(); err != nil {
		return fmt.Errorf("oops, app list tui exploded: %s", err)
	}

	return nil
}