path: root/internal/tui/modal.go

package tui

import (
	"context"
	"database/sql"
	"errors"
	"fmt"
	"strconv"
	"strings"
	"time"

	"git.tjp.lol/punchcard/internal/actions"
	"git.tjp.lol/punchcard/internal/queries"
	"git.tjp.lol/punchcard/internal/reports"

	tea "github.com/charmbracelet/bubbletea"
	"github.com/charmbracelet/lipgloss/v2"
)

type ModalType int

const (
	ModalTypeClient ModalType = iota
	ModalTypeProjectCreate
	ModalTypeProjectEdit
	ModalTypeDeleteConfirmation
	ModalTypeEntry
	ModalTypeHistoryFilter
	ModalTypeGenerateReport
	ModalTypeContractor
	ModalTypeArchivedWarning
)

func (mt ModalType) newForm() Form {
	switch mt {
	case ModalTypeEntry:
		return NewEntryEditorForm()
	case ModalTypeClient:
		return NewClientForm()
	case ModalTypeProjectCreate:
		return NewProjectCreateForm()
	case ModalTypeProjectEdit:
		return NewProjectEditForm()
	case ModalTypeHistoryFilter:
		return NewHistoryFilterForm()
	case ModalTypeGenerateReport:
		return NewGenerateReportForm()
	case ModalTypeContractor:
		return NewContractorForm()
	}

	return Form{}
}

type ModalBoxModel struct {
	Active bool

	Type ModalType

	form     Form
	editedID int64

	// For archived warning modal - store punch-in parameters
	archivedPunchInParams *ArchivedPunchInParams
}

type ArchivedPunchInParams struct {
	ClientID    string
	ProjectID   string
	Description string
	Rate        *float64
	EntityType  string // "client" or "project"
}

func (m *ModalBoxModel) HandleKeyPress(msg tea.KeyMsg) tea.Cmd {
	form, cmd := m.form.Update(msg)
	m.form = form
	return cmd
}

func (m ModalBoxModel) RenderCenteredOver(mainContent string, app AppModel) string {
	if !m.Active {
		return mainContent
	}

	modalContent := m.Render()
	base := lipgloss.NewLayer(mainContent)

	overlayStyle := lipgloss.NewStyle().Border(lipgloss.RoundedBorder()).BorderForeground(lipgloss.Color("62")).Padding(2, 4)

	overlay := lipgloss.NewLayer(overlayStyle.Render(modalContent))
	overlayWidth := overlay.GetWidth()
	overlayHeight := overlay.GetHeight()
	overlayLeft := (app.width - overlayWidth) / 2
	overlayTop := (app.height - overlayHeight) / 2

	canvas := lipgloss.NewCanvas(
		base.Z(0),
		overlay.X(overlayLeft).Y(overlayTop).Z(1),
	)

	return canvas.Render()
}

func (m ModalBoxModel) Render() string {
	switch m.Type {
	case ModalTypeEntry:
		return m.RenderFormModal("⏰ Time Entry")
	case ModalTypeDeleteConfirmation:
		return m.RenderDeleteConfirmation()
	case ModalTypeArchivedWarning:
		return m.RenderArchivedWarning()
	case ModalTypeClient:
		return m.RenderFormModal("👤 Client")
	case ModalTypeProjectCreate, ModalTypeProjectEdit:
		return m.RenderFormModal("📂 Project")
	case ModalTypeHistoryFilter:
		return m.RenderFormModal("🔍 History Filter")
	case ModalTypeGenerateReport:
		return m.RenderFormModal("📄 Generate Report")
	case ModalTypeContractor:
		return m.RenderFormModal("👤 Contractor")
	default: // REMOVE ME
		return "DEFAULT CONTENT"
	}
}

func (m ModalBoxModel) RenderFormModal(title string) string {
	return fmt.Sprintf(
		"%s\n\n%s\n\n%s Submit  %s Cancel",
		modalTitleStyle.Render(title),
		m.form.View(),
		boldStyle.Render("[Enter]"),
		boldStyle.Render("[Esc]"),
	)
}

func (m ModalBoxModel) RenderDeleteConfirmation() string {
	return fmt.Sprintf(
		"%s\n\nAre you sure you want to delete this time entry?\nThis action cannot be undone.\n\n%s Delete  %s Cancel",
		modalTitleStyle.Render("🗑️ Delete Time Entry"),
		boldStyle.Render("[Enter]"),
		boldStyle.Render("[Esc]"),
	)
}

func (m ModalBoxModel) RenderArchivedWarning() string {
	entityType := "client"
	if m.archivedPunchInParams != nil {
		entityType = m.archivedPunchInParams.EntityType
	}

	return fmt.Sprintf(
		"%s\n\nThis %s is archived.\n\nContinuing will unarchive it and start tracking time.\n\n%s Continue  %s Cancel",
		modalTitleStyle.Render("⚠️  Archived "+entityType),
		entityType,
		boldStyle.Render("[Enter]"),
		boldStyle.Render("[Esc]"),
	)
}

func (m *ModalBoxModel) activateCreateProjectModal(am AppModel) {
	m.activate(ModalTypeProjectCreate, 0, am)
	if am.selectedBox == ProjectsBox && len(am.projectsBox.clients) > 0 {
		client := am.projectsBox.clients[am.projectsBox.selectedClient]
		m.form.fields[1].SetValue(client.Name)
	}
	m.form.fields[0].Focus()
}

func (m *ModalBoxModel) activate(t ModalType, editedID int64, am AppModel) {
	m.Active = true
	m.Type = t
	m.form = t.newForm()
	m.editedID = editedID
	m.form.SetSuggestions(am)
}

func (m *ModalBoxModel) deactivate() {
	m.Active = false
}

func (m *ModalBoxModel) populateContractorFields(contractor ContractorInfo) {
	m.form.fields[0].SetValue(contractor.name)
	m.form.fields[1].SetValue(contractor.label)
	m.form.fields[2].SetValue(contractor.email)
}

func (m *ModalBoxModel) populateClientFields(client queries.Client) {
	m.form.fields[0].SetValue(client.Name)
	if client.Email.Valid {
		m.form.fields[1].SetValue(client.Email.String)
	}
	if client.BillableRate.Valid {
		m.form.fields[2].SetValue(fmt.Sprintf("%.2f", float64(client.BillableRate.Int64)/100))
	}
}

func (m *ModalBoxModel) populateProjectFields(project queries.Project) {
	m.form.fields[0].SetValue(project.Name)
	if project.BillableRate.Valid {
		m.form.fields[2].SetValue(fmt.Sprintf("%.2f", float64(project.BillableRate.Int64)/100))
	}
}

var (
	boldStyle       = lipgloss.NewStyle().Bold(true)
	modalTitleStyle = boldStyle
)

func (m *ModalBoxModel) SubmitForm(am AppModel) tea.Cmd {
	switch m.Type {
	case ModalTypeDeleteConfirmation:
		err := am.queries.RemoveTimeEntry(context.Background(), m.editedID)
		if err != nil {
			return reOpenModal()
		}
		return tea.Sequence(closeModal(), am.refreshCmd, func() tea.Msg { return recheckBounds{} })

	case ModalTypeEntry:
		if err := m.form.Error(); err != nil {
			return reOpenModal()
		}

		params, hasErrors := m.validateAndParseEntryForm(am)
		if hasErrors {
			return reOpenModal()
		}

		err := am.queries.EditTimeEntry(context.Background(), params)
		if err != nil {
			m.form.err = err
			return reOpenModal()
		}

		return tea.Sequence(closeModal(), am.refreshCmd)

	case ModalTypeClient:
		if err := m.form.Error(); err != nil {
			return reOpenModal()
		}

		var rate *float64
		if value := m.form.fields[2].Value(); value != "" {
			r, _ := strconv.ParseFloat(value, 64)
			rate = &r
		}

		if m.editedID != 0 {
			if _, err := actions.New(am.queries).EditClient(
				context.Background(),
				m.editedID,
				m.form.fields[0].Value(),
				m.form.fields[1].Value(),
				rate,
			); err != nil {
				m.form.err = err
				return reOpenModal()
			}
		} else {
			if _, err := actions.New(am.queries).CreateClient(
				context.Background(),
				m.form.fields[0].Value(),
				m.form.fields[1].Value(),
				rate,
			); err != nil {
				m.form.err = err
				return reOpenModal()
			}
		}

		return tea.Sequence(closeModal(), am.refreshCmd)

	case ModalTypeProjectCreate:
		if err := m.form.Error(); err != nil {
			return reOpenModal()
		}

		var rate *float64
		if value := m.form.fields[2].Value(); value != "" {
			r, _ := strconv.ParseFloat(value, 64)
			rate = &r
		}

		if _, err := actions.New(am.queries).CreateProject(
			context.Background(),
			m.form.fields[0].Value(),
			m.form.fields[1].Value(),
			rate,
		); err != nil {
			m.form.err = err
			return reOpenModal()
		}

		return tea.Sequence(closeModal(), am.refreshCmd)

	case ModalTypeProjectEdit:
		if err := m.form.Error(); err != nil {
			return reOpenModal()
		}

		var rate *float64
		if value := m.form.fields[1].Value(); value != "" {
			r, _ := strconv.ParseFloat(value, 64)
			rate = &r
		}

		if _, err := actions.New(am.queries).EditProject(
			context.Background(),
			m.editedID,
			m.form.fields[0].Value(),
			rate,
		); err != nil {
			m.form.err = err
			return reOpenModal()
		}

		return tea.Sequence(closeModal(), am.refreshCmd)

	case ModalTypeHistoryFilter:
		if err := m.form.Error(); err != nil {
			return reOpenModal()
		}

		// Parse date range
		dateRangeStr := m.form.fields[0].Value()
		dateRange, err := reports.ParseDateRange(dateRangeStr)
		if err != nil {
			m.form.fields[0].Err = fmt.Errorf("invalid date range: %v", err)
			return reOpenModal()
		}

		// Create new filter
		newFilter := HistoryFilter{
			StartDate: dateRange.Start,
			EndDate:   nil,
			ClientID:  nil,
			ProjectID: nil,
		}

		// Set end date if the parsed range has one
		if !dateRange.End.IsZero() {
			newFilter.EndDate = &dateRange.End
		}

		// Parse client filter if provided
		clientStr := m.form.fields[1].Value()
		if clientStr != "" {
			client, err := actions.New(am.queries).FindClient(context.Background(), clientStr)
			if err != nil {
				m.form.fields[1].Err = fmt.Errorf("client not found: %s", clientStr)
				return reOpenModal()
			}
			newFilter.ClientID = &client.ID
		}

		// Parse project filter if provided
		projectStr := m.form.fields[2].Value()
		if projectStr != "" {
			project, err := actions.New(am.queries).FindProject(context.Background(), projectStr)
			if err != nil {
				m.form.fields[2].Err = fmt.Errorf("project not found: %s", projectStr)
				return reOpenModal()
			}
			newFilter.ProjectID = &project.ID
		}

		// Return filter update message
		return tea.Sequence(closeModal(), func() tea.Msg { return updateHistoryFilter(newFilter) })

	case ModalTypeGenerateReport:
		if err := m.form.Error(); err != nil {
			return reOpenModal()
		}

		// Validate report type
		var genFunc func(context.Context, *queries.Queries, reports.ReportParams) (*reports.ReportResult, error)
		switch strings.ToLower(m.form.fields[0].Value()) {
		case "invoice":
			genFunc = reports.GenerateInvoice
		case "timesheet":
			genFunc = reports.GenerateTimesheet
		case "unified":
			genFunc = reports.GenerateUnifiedReport
		default:
			m.form.fields[0].Err = errors.New("pick one of invoice, timesheet, or unified")
			return reOpenModal()
		}

		// Parse date range
		dateRange, err := reports.ParseDateRange(m.form.fields[1].Value())
		if err != nil {
			m.form.fields[1].Err = fmt.Errorf("invalid date range: %v", err)
			return reOpenModal()
		}

		// Parse timezone
		var tz *time.Location
		tzstr := m.form.fields[5].Value()
		if tzstr == "" {
			tz = time.Local
		} else {
			zone, err := time.LoadLocation(tzstr)
			if err != nil {
				m.form.fields[5].Err = err
				return reOpenModal()
			}
			tz = zone
		}

		return generateReport(am, genFunc, reports.ReportParams{
			ClientName:  m.form.fields[2].Value(),
			ProjectName: m.form.fields[3].Value(),
			DateRange:   dateRange,
			OutputPath:  m.form.fields[4].Value(),
			Timezone:    tz,
		})

	case ModalTypeContractor:
		if err := m.form.Error(); err != nil {
			return reOpenModal()
		}

		if _, err := am.queries.UpdateContractor(context.Background(), queries.UpdateContractorParams{
			Name:  m.form.fields[0].Value(),
			Label: m.form.fields[1].Value(),
			Email: m.form.fields[2].Value(),
		}); err != nil {
			m.form.err = err
			return reOpenModal()
		}

		return tea.Sequence(closeModal(), am.refreshCmd)

	case ModalTypeArchivedWarning:
		// User confirmed unarchiving - punch in with autoUnarchive=true
		if m.archivedPunchInParams == nil {
			return nil
		}

		a := actions.New(am.queries)
		_, _ = a.PunchIn(
			context.Background(),
			m.archivedPunchInParams.ClientID,
			m.archivedPunchInParams.ProjectID,
			m.archivedPunchInParams.Description,
			m.archivedPunchInParams.Rate,
			true, // autoUnarchive
		)

		return tea.Sequence(closeModal(), am.refreshCmd)
	}

	return nil
}

func (m *ModalBoxModel) validateAndParseEntryForm(am AppModel) (queries.EditTimeEntryParams, bool) {
	var params queries.EditTimeEntryParams
	var hasErrors bool

	// Set the entry ID
	params.EntryID = m.editedID

	entry, _ := am.queries.GetTimeEntryById(context.Background(), params.EntryID)

	startTimeStr := m.form.fields[0].Value()
	startTime, err := time.ParseInLocation(time.DateTime, startTimeStr, time.Local)
	if err != nil {
		m.form.fields[0].Err = fmt.Errorf("invalid start time format")
		hasErrors = true
	} else {
		params.StartTime = startTime.UTC().Format(time.DateTime)
	}

	endTimeStr := m.form.fields[1].Value()
	if endTimeStr != "" {
		endTime, err := time.ParseInLocation(time.DateTime, endTimeStr, time.Local)
		if err != nil {
			m.form.fields[1].Err = fmt.Errorf("invalid end time format")
			hasErrors = true
		} else {
			params.EndTime = endTime.UTC().Format(time.DateTime)
		}
	} else if entry.EndTime.Valid {
		m.form.fields[1].Err = fmt.Errorf("can not re-open an entry")
		hasErrors = true
	}

	clientStr := m.form.fields[2].Value()
	if clientStr == "" {
		m.form.fields[2].Err = fmt.Errorf("client is required")
		hasErrors = true
	} else {
		client, err := actions.New(am.queries).FindClient(context.Background(), clientStr)
		if err != nil {
			m.form.fields[2].Err = fmt.Errorf("client not found: %s", clientStr)
			hasErrors = true
		} else {
			params.ClientID = client.ID
		}
	}

	projectStr := m.form.fields[3].Value()
	if projectStr != "" {
		project, err := actions.New(am.queries).FindProject(context.Background(), projectStr)
		if err != nil {
			m.form.fields[3].Err = fmt.Errorf("project not found: %s", projectStr)
			hasErrors = true
		} else {
			params.ProjectID = sql.NullInt64{Int64: project.ID, Valid: true}
		}
	}

	descriptionStr := m.form.fields[4].Value()
	if descriptionStr != "" {
		params.Description = sql.NullString{String: descriptionStr, Valid: true}
	}

	rateStr := m.form.fields[5].Value()
	if rateStr != "" {
		rate, err := strconv.ParseFloat(rateStr, 64)
		if err != nil {
			m.form.fields[5].Err = fmt.Errorf("invalid hourly rate")
			hasErrors = true
		} else {
			params.HourlyRate = sql.NullInt64{Int64: int64(rate * 100), Valid: true}
		}
	}

	return params, hasErrors
}