package main

import (
	"flag"
	"fmt"
	"os"
	"time"

	"envguard/internal/api"
	"envguard/internal/models"

	"github.com/charmbracelet/bubbles/table"
	"github.com/charmbracelet/bubbles/textinput"
	tea "github.com/charmbracelet/bubbletea"
	"github.com/charmbracelet/lipgloss"
)

var baseStyle = lipgloss.NewStyle().
	BorderStyle(lipgloss.NormalBorder()).
	BorderStyle(lipgloss.NormalBorder()).
	BorderForeground(lipgloss.Color("240"))

type viewState int

const (
	viewList viewState = iota
	viewDetail
	viewLockForm
)

type model struct {
	table        table.Model
	services     []models.Service
	user         string
	err          error
	message      string
	width        int
	height       int
	state        viewState
	history      []models.HistoryEntry
	historyTable table.Model
	inputs       []textinput.Model
	focusIndex   int
}

type tickMsg time.Time

func tick() tea.Cmd {
	return tea.Tick(5*time.Second, func(t time.Time) tea.Msg {
		return tickMsg(t)
	})
}

func (m model) Init() tea.Cmd {
	// If in detail view, only tick (no auto refresh of history for now to keep it simple)
	if m.state == viewDetail {
		return tick()
	}
	return tea.Batch(fetchServices, tick())
}

func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
	var cmd tea.Cmd
	switch msg := msg.(type) {
	case tickMsg:
		if m.state == viewLockForm {
			return m, nil
		}
		return m, tea.Batch(fetchServices, tick())
	case tea.KeyMsg:
		if m.state == viewLockForm {
			return m.updateLockForm(msg)
		}
		switch msg.String() {
		case "esc", "q", "ctrl+c":
			if m.state == viewDetail {
				m.state = viewList
				m.table.Focus()
				return m, nil
			}
			return m, tea.Quit
		case "d":
			if m.state == viewList {
				selected := m.table.SelectedRow()
				if selected != nil {
					serviceName := selected[0]
					m.state = viewDetail
					return m, fetchHistoryCmd(serviceName)
				}
			}
		case "enter":
			if m.state == viewDetail {
				return m, nil
			}
			selected := m.table.SelectedRow()
			if selected == nil {
				return m, nil
			}
			serviceName := selected[0]
			// Find service state
			for _, s := range m.services {
				if s.Name == serviceName {
					if s.IsLocked {
						if s.LockedBy == m.user {
							// Unlock
							err := api.UnlockService(serviceName, m.user)
							if err != nil {
								m.message = "Error unlocking: " + err.Error()
							} else {
								m.message = "Unlocked " + serviceName
							}
							return m, fetchServices
						} else {
							m.message = "Cannot unlock service locked by " + s.LockedBy
						}
					} else {
						// Open Lock Form
						m.state = viewLockForm
						m.inputs[0].SetValue("")
						m.inputs[1].SetValue("")
						m.focusIndex = 0
						m.inputs[0].Focus()
						return m, nil
					}
					return m, fetchServices
				}
			}
		case "r":
			return m, fetchServices
		}
	case tea.WindowSizeMsg:
		m.width = msg.Width
		m.height = msg.Height

		// Calculate available dimensions
		// Borders take 2 chars total width (1 left + 1 right)
		// We add extra safety margin (total -6) to avoid last-column wrap issues
		availWidth := m.width - 15

		// Adjust column widths dynamically
		// Total weight = 100%
		cols := m.table.Columns()
		// Calculate widths ensuring at least minimums
		// Columns: SERVICE, STATUS, USER, TICKETS, TIME
		// Main View
		c0 := int(float64(availWidth) * 0.25) // SERVICE
		c1 := int(float64(availWidth) * 0.15) // STATUS
		c2 := int(float64(availWidth) * 0.15) // USER
		c3 := int(float64(availWidth) * 0.20) // TICKETS
		c4 := availWidth - c0 - c1 - c2 - c3  // TIME

		cols[0].Width = c0
		cols[1].Width = c1
		cols[2].Width = c2
		cols[3].Width = c3
		cols[4].Width = c4

		m.table.SetColumns(cols)
		m.table.SetWidth(availWidth)

		// History View (Split 50/50 approx)
		// Left Pane (Table)
		// Columns: ACTION, USER, TIME (Tickets and Desc moved to right pane)
		// but wait, we need to match the history table initialization cols...
		// Let's redefine history table cols to match the new layout

		hWidth := availWidth / 2
		hc0 := int(float64(hWidth) * 0.2) // ACTION
		hc1 := int(float64(hWidth) * 0.3) // USER
		hc2 := hWidth - hc0 - hc1 - 5     // TIME (approx)

		hCols := m.historyTable.Columns()
		// Ensure we have correct number of columns.
		// Previous task added TICKETS and DESC columns. We will remove them from the table
		// and show them in the right pane instead, to save space.
		// Wait, I should not change the columns definition in main() if I don't want to re-init.
		// Re-init in main() is better. I will do that in a separate chunk.
		// For now, let's assume I will reduce the history table columns to 3.

		// Actually, I can just hide or set width 0 for columns I don't want to see?
		// No, better to stick to 3 visible columns for the table.

		if len(hCols) >= 3 {
			hCols[0].Width = hc0
			hCols[1].Width = hc1
			hCols[len(hCols)-1].Width = hc2
			// Set middle columns to 0 if they exist (TICKETS, DESC)
			for i := 2; i < len(hCols)-1; i++ {
				hCols[i].Width = 0
			}
		}

		m.historyTable.SetColumns(hCols)
		m.historyTable.SetWidth(hWidth)

		// Header + Footer + padding calculation
		availableHeight := m.height - 7
		if availableHeight < 5 {
			availableHeight = 5
		}
		m.table.SetHeight(availableHeight)
	case []models.Service:
		m.services = msg
		rows := []table.Row{}
		for _, s := range msg {
			status := "🟢 LIBRE"
			if s.IsLocked {
				status = "🔴 LOCKED"
			}
			user := s.LockedBy
			if user == "" {
				user = "--"
			}
			timeStr := "--"
			if s.IsLocked {
				duration := time.Since(s.LockedAt)
				timeStr = fmt.Sprintf("Hace %s", duration.Round(time.Second))
			}

			rows = append(rows, table.Row{s.Name, status, user, s.JiraTickets, timeStr})
		}
		m.table.SetRows(rows)
		m.message = "Refreshed"
	case []models.HistoryEntry:
		m.history = msg
		rows := []table.Row{}
		for _, h := range msg {
			rows = append(rows, table.Row{
				h.Action,
				h.User,
				h.JiraTickets,
				h.Description,
				h.Timestamp.Format("2006-01-02 15:04:05"),
			})
		}
		m.historyTable.SetRows(rows)
		m.historyTable.SetRows(rows)
		// Resize handled in WindowSizeMsg now, but we need to trigger it if not triggered.
		// Actually m.width is stored.

		// Recalculate widths just in case
		availWidth := m.width - 10
		if availWidth > 0 {
			hWidth := availWidth / 2
			hc0 := int(float64(hWidth) * 0.2) // ACTION
			hc1 := int(float64(hWidth) * 0.3) // USER
			hc2 := hWidth - hc0 - hc1 - 5     // TIME

			hCols := m.historyTable.Columns()
			if len(hCols) >= 3 {
				hCols[0].Width = hc0
				hCols[1].Width = hc1
				hCols[len(hCols)-1].Width = hc2
				for i := 2; i < len(hCols)-1; i++ {
					hCols[i].Width = 0
				}
			}
			m.historyTable.SetColumns(hCols)
			m.historyTable.SetWidth(hWidth)
		}

		m.historyTable.SetHeight(m.table.Height())
	case error:
		m.err = msg
	}

	if m.state == viewList {
		m.table, cmd = m.table.Update(msg)
	} else {
		m.historyTable, cmd = m.historyTable.Update(msg)
	}
	return m, cmd
}

func (m model) updateLockForm(msg tea.Msg) (tea.Model, tea.Cmd) {
	switch msg := msg.(type) {
	case tea.KeyMsg:
		switch msg.String() {
		case "esc":
			m.state = viewList
			m.table.Focus()
			return m, nil
		case "tab", "shift+tab", "enter", "up", "down":
			s := msg.String()

			if s == "enter" && m.focusIndex == len(m.inputs)-1 {
				// Submit
				serviceName := m.table.SelectedRow()[0]
				jira := m.inputs[0].Value()
				desc := m.inputs[1].Value()

				err := api.LockService(serviceName, m.user, jira, desc)
				if err != nil {
					m.message = "Error locking: " + err.Error()
				} else {
					m.message = "Locked " + serviceName
				}
				m.state = viewList
				m.table.Focus()
				return m, fetchServices
			}

			if s == "up" || s == "shift+tab" {
				m.focusIndex--
			} else {
				m.focusIndex++
			}

			if m.focusIndex > len(m.inputs)-1 {
				m.focusIndex = 0
			} else if m.focusIndex < 0 {
				m.focusIndex = len(m.inputs) - 1
			}

			cmds := make([]tea.Cmd, len(m.inputs))
			for i := 0; i <= len(m.inputs)-1; i++ {
				if i == m.focusIndex {
					cmds[i] = m.inputs[i].Focus()
					continue
				}
				m.inputs[i].Blur()
			}
			return m, tea.Batch(cmds...)
		}
	}

	cmd := m.updateInputs(msg)
	return m, cmd
}

func (m *model) updateInputs(msg tea.Msg) tea.Cmd {
	cmds := make([]tea.Cmd, len(m.inputs))
	for i := range m.inputs {
		m.inputs[i], cmds[i] = m.inputs[i].Update(msg)
	}
	return tea.Batch(cmds...)
}

func (m model) View() string {
	if m.err != nil {
		return fmt.Sprintf("Error: %v\nPress q to quit", m.err)
	}

	if m.width == 0 {
		return "Loading..."
	}

	userInfo := fmt.Sprintf("User: %s", m.user)
	if m.message != "" {
		userInfo += " | " + m.message
	}

	// Dimensions
	appWidth := m.width - 2
	appHeight := m.height - 2
	if appWidth < 20 {
		appWidth = 20
	}
	if appHeight < 10 {
		appHeight = 10
	}

	// Content inside border
	contentWidth := appWidth - 2

	// Local Styles
	headerStyle := lipgloss.NewStyle().
		Bold(true).
		Foreground(lipgloss.Color("252")).
		PaddingLeft(1).
		PaddingBottom(1).
		Width(contentWidth)

	infoStyle := lipgloss.NewStyle().
		PaddingLeft(1).
		Foreground(lipgloss.Color("241")).
		Width(contentWidth)

	footerStyle := lipgloss.NewStyle().
		Foreground(lipgloss.Color("240")).
		Align(lipgloss.Center).
		Width(contentWidth)

	var mainView string
	if m.state == viewList {
		mainView = m.table.View()
	} else if m.state == viewLockForm {
		mainView = lipgloss.JoinVertical(lipgloss.Left,
			fmt.Sprintf("Locking service: %s", m.table.SelectedRow()[0]),
			"",
			"Jira Tickets:",
			m.inputs[0].View(),
			"",
			"Description:",
			m.inputs[1].View(),
			"",
			"(Enter to submit, Esc to cancel)",
		)
	} else {
		// History View
		// Left Pane: History Table
		leftPane := m.historyTable.View()

		// Right Pane: Details
		var rightPane string
		selected := m.historyTable.SelectedRow()
		if selected != nil {
			// Extract data from selected row
			// Columns: ACTION, USER, TICKETS, DESC, TIME
			// Indices: 0,      1,    2,       3,    4
			action := selected[0]
			user := selected[1]
			tickets := selected[2]
			desc := selected[3]
			timestamp := selected[4]

			detailStyle := lipgloss.NewStyle().
				Padding(1).
				Border(lipgloss.RoundedBorder()).
				BorderForeground(lipgloss.Color("63")).
				Width(m.width/2 - 5).
				Height(m.height - 8)

			content := fmt.Sprintf(
				"ACTION: %s\n\nUSER: %s\n\nTIME: %s\n\nJIRA TICKETS:\n%s\n\nDESCRIPTION:\n%s",
				action, user, timestamp, tickets, desc,
			)
			rightPane = detailStyle.Render(content)
		} else {
			rightPane = "Select an entry to view details."
		}

		mainView = lipgloss.JoinHorizontal(lipgloss.Top,
			leftPane,
			rightPane,
		)
	}

	// Render Content
	content := lipgloss.JoinVertical(lipgloss.Left,
		headerStyle.Render("🛡️  ENV-GUARD v1.0"),
		infoStyle.Render(userInfo),
		mainView,
		footerStyle.Render("[↑/↓] Navigate  [Enter] Toggle Lock  [d] History  [r] Refresh  [q] Quit"),
	)

	// Create Border Style locally
	borderStyle := lipgloss.NewStyle().
		// BorderStyle(lipgloss.NormalBorder()).
		// BorderForeground(lipgloss.Color("240")).
		Width(appWidth).
		Height(appHeight - 2)

	// Wrap in Border
	gui := borderStyle.Render(content)

	// Place in center of screen
	return lipgloss.Place(m.width, m.height, lipgloss.Center, lipgloss.Center, gui)
}

func fetchServices() tea.Msg {
	services, err := api.GetServices()
	if err != nil {
		return err
	}
	return services
}

func fetchHistoryCmd(serviceName string) tea.Cmd {
	return func() tea.Msg {
		hist, err := api.GetHistory(serviceName)
		if err != nil {
			return err
		}
		return hist
	}
}

func main() {
	serverURL := flag.String("server", "http://localhost:8080", "URL of the EnvGuard server")
	flag.Parse()

	api.SetBaseURL(*serverURL)

	user := os.Getenv("USER")
	if user == "" {
		user = "guest"
	}

	columns := []table.Column{
		{Title: "SERVICE", Width: 20},
		{Title: "STATUS", Width: 15},
		{Title: "USER", Width: 15},
		{Title: "TICKETS", Width: 15},
		{Title: "TIME", Width: 20},
	}

	t := table.New(
		table.WithColumns(columns),
		table.WithFocused(true),
		table.WithHeight(10),
	)

	s := table.DefaultStyles()
	s.Header = s.Header.
		BorderStyle(lipgloss.NormalBorder()).
		BorderForeground(lipgloss.Color("240")).
		BorderBottom(true).
		Bold(true)
	s.Selected = s.Selected.
		Foreground(lipgloss.Color("229")).
		Background(lipgloss.Color("57")).
		Bold(false)
	t.SetStyles(s)

	// History Table
	// Reduced columns for split view
	hCols := []table.Column{
		{Title: "ACTION", Width: 10},
		{Title: "USER", Width: 15},
		// Hidden columns for data storage in row, but width 0
		{Title: "TICKETS", Width: 0},
		{Title: "DESC", Width: 0},
		{Title: "TIME", Width: 20},
	}
	ht := table.New(
		table.WithColumns(hCols),
		table.WithFocused(true),
		table.WithHeight(10),
	)
	ht.SetStyles(s)

	inputs := make([]textinput.Model, 2)
	inputs[0] = textinput.New()
	inputs[0].Placeholder = "D3A-XXXX"
	inputs[0].Focus()
	inputs[0].CharLimit = 50
	inputs[0].Width = 30

	inputs[1] = textinput.New()
	inputs[1].Placeholder = "What are you doing?"
	inputs[1].CharLimit = 100
	inputs[1].Width = 50

	m := model{
		table:        t,
		historyTable: ht,
		user:         user,
		inputs:       inputs,
	}

	if _, err := tea.NewProgram(m, tea.WithAltScreen()).Run(); err != nil {
		fmt.Println("Error running program:", err)
		os.Exit(1)
	}
}