package main

import (
	"image/color"
	"time"

	"fyne.io/fyne/v2"
	"fyne.io/fyne/v2/canvas"
	"fyne.io/fyne/v2/container"
	"fyne.io/fyne/v2/theme"
	"fyne.io/fyne/v2/widget"
)

type uiParts struct {
	outKey     *widget.Entry
	msg        *widget.Entry
	peer       *widget.Entry
	cipherOut  *widget.Entry
	payload    *widget.Entry
	plainOut   *widget.Entry
	toastLabel *widget.Label
}

func buildEntries() *uiParts {
	p := &uiParts{
		outKey:     widget.NewMultiLineEntry(),
		msg:        widget.NewMultiLineEntry(),
		peer:       widget.NewMultiLineEntry(),
		cipherOut:  widget.NewMultiLineEntry(),
		payload:    widget.NewMultiLineEntry(),
		plainOut:   widget.NewMultiLineEntry(),
		toastLabel: widget.NewLabel(""),
	}
	p.outKey.SetPlaceHolder("Veřejný klíč / certifikát…")
	p.msg.SetPlaceHolder("Sem napiš zprávu…")
	p.peer.SetPlaceHolder("-----BEGIN PUBLIC KEY----- … nebo CERTIFICATE …")
	p.cipherOut.SetPlaceHolder(`{"ek":"…","n":"…","ct":"…"}`)
	p.payload.SetPlaceHolder(`{"ek":"…","n":"…","ct":"…"}`)
	p.plainOut.SetPlaceHolder("Dešifrovaná zpráva…")
	// Zvýšení výšky (více řádků viditelně)
	p.outKey.SetMinRowsVisible(10)
	p.peer.SetMinRowsVisible(6)
	p.msg.SetMinRowsVisible(8)
	p.cipherOut.SetMinRowsVisible(8)
	p.payload.SetMinRowsVisible(8)
	p.plainOut.SetMinRowsVisible(8)
	p.toastLabel.Hide()
	return p
}

func (p *uiParts) showToast(msg string) {
	fyne.Do(func() {
		p.toastLabel.SetText(msg)
		p.toastLabel.Show()
	})
	time.AfterFunc(1500*time.Millisecond, func() {
		fyne.Do(func() {
			if p.toastLabel.Text == msg { // avoid race if overwritten
				p.toastLabel.SetText("")
				p.toastLabel.Hide()
			}
		})
	})
}

// theme toggle
// Simple theme variants using built-in with preference respecting variant
// lightOverride & darkOverride implement fyne.Theme with adjusted primary/background colors.
// minimal two themes (light/dark) customizing a couple of colors
type simpleTheme struct{ dark bool }

func (s simpleTheme) Color(n fyne.ThemeColorName, v fyne.ThemeVariant) color.Color {
	base := theme.DefaultTheme().Color(n, v)
	if !s.dark {
		return base
	}
	// dark tweak: slightly desaturate backgrounds
	if n == theme.ColorNameBackground || n == theme.ColorNameButton {
		return color.NRGBA{R: 30, G: 34, B: 39, A: 255}
	}
	return base
}
func (s simpleTheme) Font(st fyne.TextStyle) fyne.Resource    { return theme.DefaultTheme().Font(st) }
func (s simpleTheme) Icon(n fyne.ThemeIconName) fyne.Resource { return theme.DefaultTheme().Icon(n) }
func (s simpleTheme) Size(n fyne.ThemeSizeName) float32       { return theme.DefaultTheme().Size(n) }

var currentDark bool

func newThemeToggle(app fyne.App, parts *uiParts) *widget.Button {
	return widget.NewButton("🌗 Motiv", func() {
		currentDark = !currentDark
		app.Settings().SetTheme(simpleTheme{dark: currentDark})
		if currentDark {
			parts.showToast("Dark")
		} else {
			parts.showToast("Light")
		}
	})
}

// Build key section
func buildIdentityTab(parts *uiParts, svc ServiceFacade) fyne.CanvasObject {
	btnCopyPub := widget.NewButton("Copy public.pem", func() { copyClip(svc.PublicPEM(), parts) })
	btnCopyCrt := widget.NewButton("Copy identity.crt", func() { copyClip(svc.PublicCert(), parts) })
	btnShowPub := widget.NewButton("Show pub", func() { parts.outKey.SetText(svc.PublicPEM()) })
	btnShowCrt := widget.NewButton("Show crt", func() { parts.outKey.SetText(svc.PublicCert()) })
	btnClear := widget.NewButton("Clear", func() { parts.outKey.SetText("") })
	btnPaste := widget.NewButton("Paste", func() { parts.outKey.SetText(fyne.CurrentApp().Clipboard().Content()) })

	tileIdentity := buttonTile(btnCopyPub, btnCopyCrt, btnPaste, btnShowPub, btnShowCrt, btnClear)
	group := container.NewVBox(
		widget.NewLabelWithStyle("Moje identita", fyne.TextAlignLeading, fyne.TextStyle{Bold: true}),
		tileIdentity,
		parts.outKey,
	)
	return container.NewVScroll(group)
}

// Helper functions separated to avoid circular dependency with encrypt.Service
// We'll adapt by passing a small facade interface if needed.

type ServiceFacade interface {
	Encrypt(msg, peer string) (string, error)
	Decrypt(json string) (string, error)
	PublicPEM() string
	PublicCert() string
}

func copyClip(s string, parts *uiParts) {
	fyne.CurrentApp().Clipboard().SetContent(s)
	parts.showToast("Zkopírováno")
}

// (Removed legacy buildEncryptSection and buildDecryptSection)

// assembleResponsive builds split view that collapses for narrow widths
// Tab: Encrypt
func buildEncryptTab(parts *uiParts, svc ServiceFacade) fyne.CanvasObject {
	parts.cipherOut.Disable() // read only output
	peerBtns := buttonTile(
		widget.NewButton("Paste", func() { parts.peer.SetText(fyne.CurrentApp().Clipboard().Content()) }),
		widget.NewButton("Clear", func() { parts.peer.SetText("") }),
	)
	encAction := func() {
		m := parts.msg.Text
		p := parts.peer.Text
		if m == "" || p == "" {
			parts.showToast("Chybí data")
			return
		}
		go func(msg, peer string) {
			res, err := svc.Encrypt(msg, peer)
			if err != nil {
				fyne.Do(func() { parts.cipherOut.SetText(""); parts.showToast("Chyba") })
				return
			}
			fyne.Do(func() { parts.cipherOut.SetText(res); parts.showToast("OK") })
		}(m, p)
	}
	msgBtns := buttonTile(
		widget.NewButton("Encrypt", encAction),
		widget.NewButton("Copy", func() { copyClip(parts.cipherOut.Text, parts) }),
	)
	resultBtns := buttonTile(widget.NewButton("Copy", func() { copyClip(parts.cipherOut.Text, parts) }))
	group := container.NewVBox(
		widget.NewLabelWithStyle("Šifrování", fyne.TextAlignLeading, fyne.TextStyle{Bold: true}),
		widget.NewLabel("Veřejný klíč příjemce"), peerBtns, parts.peer,
		widget.NewLabel("Zpráva"), msgBtns, parts.msg,
		widget.NewLabel("Výsledek"), resultBtns, parts.cipherOut,
	)
	return container.NewVScroll(group)
}

// Tab: Decrypt
func buildDecryptTab(parts *uiParts, svc ServiceFacade) fyne.CanvasObject {
	parts.plainOut.Disable()
	decryptAction := func() {
		pl := parts.payload.Text
		if pl == "" {
			parts.showToast("Chybí payload")
			return
		}
		go func(js string) {
			res, err := svc.Decrypt(js)
			if err != nil {
				fyne.Do(func() { parts.plainOut.SetText(""); parts.showToast("Chyba") })
				return
			}
			fyne.Do(func() { parts.plainOut.SetText(res); parts.showToast("OK") })
		}(pl)
	}
	payloadBtns := buttonTile(
		widget.NewButton("Paste+Decrypt", func() {
			clip := fyne.CurrentApp().Clipboard().Content()
			parts.payload.SetText(clip)
			decryptAction()
		}),
		// widget.NewButton("Decrypt", decryptAction),
		widget.NewButton("Clear", func() { parts.payload.SetText("") }),
	)
	plainBtns := buttonTile(widget.NewButton("Copy", func() { copyClip(parts.plainOut.Text, parts) }))
	group := container.NewVBox(
		widget.NewLabelWithStyle("Dešifrování", fyne.TextAlignLeading, fyne.TextStyle{Bold: true}),
		widget.NewLabel("Payload"), payloadBtns, parts.payload,
		widget.NewLabel("Výsledek"), plainBtns, parts.plainOut,
	)
	return container.NewVScroll(group)
}

func buildTabbedUI(parts *uiParts, svc ServiceFacade) fyne.CanvasObject {
	idTab := container.NewTabItem("Identita", buildIdentityTab(parts, svc))
	encTab := container.NewTabItem("Šifrování", buildEncryptTab(parts, svc))
	decTab := container.NewTabItem("Dešifrování", buildDecryptTab(parts, svc))
	tabs := container.NewAppTabs(idTab, encTab, decTab)
	tabs.SetTabLocation(container.TabLocationTop)

	// top bar with theme toggle
	themeBtn := newThemeToggle(fyne.CurrentApp(), parts)
	// load preferences
	prefs := fyne.CurrentApp().Preferences()
	if prefs != nil {
		idx := prefs.IntWithFallback("lastTab", 0)
		if idx >= 0 && idx < len(tabs.Items) {
			tabs.SelectIndex(idx)
		}
		if prefs.Bool("darkTheme") {
			currentDark = true
			fyne.CurrentApp().Settings().SetTheme(simpleTheme{dark: true})
		}
	}
	tabs.OnSelected = func(ti *container.TabItem) {
		if prefs != nil {
			prefs.SetInt("lastTab", tabs.SelectedIndex())
		}
	}
	// wrap toggle to persist theme choice
	oldAction := themeBtn.OnTapped
	themeBtn.OnTapped = func() {
		oldAction()
		if prefs != nil {
			prefs.SetBool("darkTheme", currentDark)
		}
	}
	topBar := container.NewBorder(nil, nil, nil, themeBtn, tabs)
	return container.NewBorder(nil, parts.toastLabel, nil, nil, topBar)
}

// buttonTile renders buttons above a related entry with a colored background spanning full width
func buttonTile(btns ...fyne.CanvasObject) fyne.CanvasObject {
	if len(btns) == 0 {
		return widget.NewLabel("")
	}
	cols := len(btns)
	if cols > 3 {
		cols = 3
	} // wrap into multiple rows if many
	grid := container.NewGridWithColumns(cols, btns...)
	bgColor := color.NRGBA{R: 240, G: 240, B: 245, A: 255}
	if currentDark {
		bgColor = color.NRGBA{R: 50, G: 54, B: 60, A: 255}
	}
	rect := canvas.NewRectangle(bgColor)
	rect.SetMinSize(fyne.NewSize(100, 38))
	padded := container.NewPadded(grid)
	return container.NewStack(rect, padded)
}