package page

import (
	"fmt"
	"os"
	"path/filepath"
	"strconv"
	"strings"
	"time"

	"github.com/go-gl/gl/v3.3-core/gl"
	"github.com/go-gl/mathgl/mgl32"
	"github.com/veandco/go-sdl2/sdl"
	"rhemawavetech.com/rhemawave/internal/colors"
	"rhemawavetech.com/rhemawave/internal/db"
	"rhemawavetech.com/rhemawave/internal/fontManager"
	"rhemawavetech.com/rhemawave/internal/shaderManager"
)

var GitVersion = "dev"

type Welcome struct {
	Base
	title              StringItem
	version            StringItem
	prompt             StringItem
	note               StringItem
	licenseInfoHeading StringItem
	emailDisplay       StringItem
	licenseKeyDisplay  StringItem
	displayStatus      StringItem
	sdlDisplayStatus   StringItem
	hasLicenseInfo     bool
	lastDisplayUpdate  time.Time
	drmDisplayCount    int
	sdlDisplayCount    int
	baseFontSize       int // cached from db at init
}

// countConnectedDisplays returns the number of connected displays via DRM
func countConnectedDisplays() int {
	matches, err := filepath.Glob("/sys/class/drm/card*/status")
	if err != nil {
		return 0
	}

	connected := 0
	for _, path := range matches {
		content, err := os.ReadFile(path)
		if err != nil {
			continue
		}

		status := strings.TrimSpace(string(content))
		if status == "connected" {
			connected++
		}
	}

	return connected
}

// countSDLDisplays returns the number of displays detected by SDL
func countSDLDisplays() int {
	numDisplays, err := sdl.GetNumVideoDisplays()
	if err != nil {
		return 0
	}
	return numDisplays
}

// updateDisplayCounts updates the display count textures
func (p *Welcome) updateDisplayCounts() error {
	// Get font
	fm := fontManager.Get()
	font, ok := fm.GetFont("Roboto-Regular")
	if !ok {
		return fmt.Errorf("unable to fetch font")
	}

	// Get base font size
	baseFontSizeStr, err := db.GetConfigValue("init_font_size")
	if err != nil {
		return fmt.Errorf("retrieving init_font_size from db: %w", err)
	}
	baseFontSize, err := strconv.Atoi(baseFontSizeStr)
	if err != nil {
		return fmt.Errorf("parsing init_font_size: %w", err)
	}

	// Update DRM count
	p.drmDisplayCount = countConnectedDisplays()

	// Delete old texture
	if p.displayStatus.ID != 0 {
		gl.DeleteTextures(1, &p.displayStatus.ID)
	}

	// Create new texture
	displayStatusText := fmt.Sprintf("Connected Displays: %d", p.drmDisplayCount)
	p.displayStatus, err = NewStringItem(displayStatusText, font, colors.White)
	if err != nil {
		return fmt.Errorf("unable to create display status texture: %w", err)
	}

	displayStatusScale := float32(24) / float32(baseFontSize)
	p.displayStatus.Scale(displayStatusScale)

	// Update SDL count
	p.sdlDisplayCount = countSDLDisplays()

	// Delete old texture
	if p.sdlDisplayStatus.ID != 0 {
		gl.DeleteTextures(1, &p.sdlDisplayStatus.ID)
	}

	// Create new texture
	sdlDisplayStatusText := fmt.Sprintf("SDL Displays Detected: %d", p.sdlDisplayCount)
	p.sdlDisplayStatus, err = NewStringItem(sdlDisplayStatusText, font, colors.White)
	if err != nil {
		return fmt.Errorf("unable to create SDL display status texture: %w", err)
	}

	p.sdlDisplayStatus.Scale(displayStatusScale)

	return nil
}

// Init performs basic page initialization and creation of static assets.
func (p *Welcome) Init(app ApplicationInterface) error {

	title := "Rhema Wave"
	version := GitVersion
	prompt := "Press F2 to Start, or F3 for Settings"
	note := "You can always press F1 to return here"

	if err := p.Base.Init(app); err != nil {
		return fmt.Errorf("failed base page initialization: %w", err)
	}

	// Get font
	fm := fontManager.Get()
	font, ok := fm.GetFont("Roboto-Regular")
	if !ok {
		return fmt.Errorf("unable to fetch font")
	}

	// Create title texture
	var err error
	p.title, err = NewStringItem(title, font, colors.White)
	if err != nil {
		return fmt.Errorf("unable to create title string texture: %w", err)
	}

	// Create version texture
	versionString := "Version: " + version
	p.version, err = NewStringItem(versionString, font, colors.White)
	if err != nil {
		return fmt.Errorf("unable to create version string texture: %w", err)
	}

	// Create prompt texture
	p.prompt, err = NewStringItem(prompt, font, colors.White)
	if err != nil {
		return fmt.Errorf("unable to create prompt string texture: %w", err)
	}

	// Create note texture
	p.note, err = NewStringItem(note, font, colors.White)
	if err != nil {
		return fmt.Errorf("unable to create note string texture: %w", err)
	}

	// Initialize display counts
	p.lastDisplayUpdate = time.Now()
	if err := p.updateDisplayCounts(); err != nil {
		return fmt.Errorf("unable to update display counts: %w", err)
	}

	// Load license information from database
	emailAddress, err := db.GetConfigValue("email_address")
	if err != nil {
		return fmt.Errorf("retrieving email_address from db: %w", err)
	}

	licenseKey, err := db.GetConfigValue("license_key")
	if err != nil {
		return fmt.Errorf("retrieving license_key from db: %w", err)
	}

	// Create license info textures if data exists
	if emailAddress != "" || licenseKey != "" {
		p.hasLicenseInfo = true

		// Create heading
		p.licenseInfoHeading, err = NewStringItem("License Info", font, colors.White)
		if err != nil {
			return fmt.Errorf("unable to create license info heading texture: %w", err)
		}

		// Create email display if exists
		if emailAddress != "" {
			emailText := fmt.Sprintf("Email: %s", emailAddress)
			p.emailDisplay, err = NewStringItem(emailText, font, colors.White)
			if err != nil {
				return fmt.Errorf("unable to create email display texture: %w", err)
			}
		}

		// Create license key display if exists
		if licenseKey != "" {
			licenseKeyText := fmt.Sprintf("License Key: %s", licenseKey)
			p.licenseKeyDisplay, err = NewStringItem(licenseKeyText, font, colors.White)
			if err != nil {
				return fmt.Errorf("unable to create license key display texture: %w", err)
			}
		}
	}

	// Get base font size from database
	baseFontSizeStr, err := db.GetConfigValue("init_font_size")
	if err != nil {
		return fmt.Errorf("retrieving init_font_size from db: %w", err)
	}
	baseFontSize, err := strconv.Atoi(baseFontSizeStr)
	if err != nil {
		return fmt.Errorf("parsing init_font_size: %w", err)
	}

	p.baseFontSize = baseFontSize

	// Scale the note text
	fontSize := int32(32)
	scale := float32(fontSize) / float32(baseFontSize)
	p.note.Scale(scale * 0.75)

	// Scale license info texts
	if p.hasLicenseInfo {
		licenseInfoScale := float32(28) / float32(baseFontSize)
		p.licenseInfoHeading.Scale(licenseInfoScale)
		if p.emailDisplay.ID != 0 {
			p.emailDisplay.Scale(licenseInfoScale * 0.85)
		}
		if p.licenseKeyDisplay.ID != 0 {
			p.licenseKeyDisplay.Scale(licenseInfoScale * 0.85)
		}
	}

	return nil
}

// HandleEvent processes SDL events and handles them appropriately for the Welcome page.
func (p *Welcome) HandleEvent(event *sdl.Event) error {
	return nil
}

// Update updates animations and changing textures and other changes using `dt` which represents a time delta in float32.
func (p *Welcome) Update(dt float32) error {
	// Update display counts every 2 seconds
	if time.Since(p.lastDisplayUpdate) >= 2*time.Second {
		if err := p.updateDisplayCounts(); err != nil {
		}
		p.lastDisplayUpdate = time.Now()
	}
	return nil
}

func (p *Welcome) Render() error {
	baseFontSize := p.baseFontSize
	sm := shaderManager.Get()
	verticalMargin := int32(20)

	// 1) Calculate scales
	titleFontSize := int32(64)
	bodyFontSize := int32(32)

	titleScale := float32(titleFontSize) / float32(baseFontSize)
	bodyScale := float32(bodyFontSize) / float32(baseFontSize)

	// 2) Calculate dimensions (scaled)
	titleW := float32(p.title.W) * titleScale
	titleH := float32(p.title.H) * titleScale
	titleDim := mgl32.Vec2{titleW, titleH}

	versionW := float32(p.version.W) * bodyScale
	versionH := float32(p.version.H) * bodyScale
	versionDim := mgl32.Vec2{versionW, versionH}

	promptW := float32(p.prompt.W) * bodyScale
	promptH := float32(p.prompt.H) * bodyScale
	promptDim := mgl32.Vec2{promptW, promptH}

	// p.note already scaled in Init via p.note.Scale(scale*0.75)
	noteDim := p.note.RawDimensions()
	noteW, noteH := noteDim[0], noteDim[1]

	// 3) Calculate total height of the vertical stack
	totalH := int32(titleH) + verticalMargin +
		int32(versionH) + verticalMargin +
		int32(promptH) + verticalMargin +
		int32(noteH)

	// 4) Y-up layout: start from the TOP of the centered stack and step DOWN
	top := p.Base.ScreenCenterY + totalH/2

	titleY := top - int32(titleH) // Title sits at the top
	versionY := titleY - verticalMargin - int32(versionH)
	p.prompt.Y = versionY - verticalMargin - int32(promptH)
	p.note.Y = p.prompt.Y - verticalMargin - int32(noteH)

	// 5) Center X for each item
	titleX := p.Base.ScreenCenterX - int32(titleW/2)
	versionX := p.Base.ScreenCenterX - int32(versionW/2)
	p.prompt.X = p.Base.ScreenCenterX - int32(promptW/2)
	p.note.X = p.Base.ScreenCenterX - int32(noteW/2)

	titlePos := mgl32.Vec2{float32(titleX), float32(titleY)}
	versionPos := mgl32.Vec2{float32(versionX), float32(versionY)}

	// 6) Position display status in bottom left corner
	displayStatusDim := p.displayStatus.RawDimensions()
	displayStatusH := displayStatusDim[1]

	// sdlDisplayStatusDim := p.sdlDisplayStatus.RawDimensions()
	// sdlDisplayStatusH := sdlDisplayStatusDim[1]

	displayStatusMargin := int32(5)

	p.displayStatus.X = 15
	p.displayStatus.Y = 15

	p.sdlDisplayStatus.X = 15
	p.sdlDisplayStatus.Y = 15 + int32(displayStatusH) + displayStatusMargin

	// 7) Position license info at bottom center
	if p.hasLicenseInfo {
		licenseInfoMargin := int32(10)
		bottomMargin := int32(20)

		// License info items are already scaled in Init
		licenseHeadingDim := p.licenseInfoHeading.RawDimensions()
		licenseHeadingW, licenseHeadingH := licenseHeadingDim[0], licenseHeadingDim[1]

		var emailDisplayH, licenseKeyDisplayH float32
		if p.emailDisplay.ID != 0 {
			emailDisplayDim := p.emailDisplay.RawDimensions()
			emailDisplayH = emailDisplayDim[1]
		}
		if p.licenseKeyDisplay.ID != 0 {
			licenseKeyDisplayDim := p.licenseKeyDisplay.RawDimensions()
			licenseKeyDisplayH = licenseKeyDisplayDim[1]
		}

		// Calculate total height of license info block
		licenseInfoTotalH := int32(licenseHeadingH)
		if p.emailDisplay.ID != 0 {
			licenseInfoTotalH += int32(emailDisplayH) + licenseInfoMargin
		}
		if p.licenseKeyDisplay.ID != 0 {
			licenseInfoTotalH += int32(licenseKeyDisplayH) + licenseInfoMargin
		}

		// Start from bottom and work up
		currentY := bottomMargin

		// License key (bottom-most if it exists)
		if p.licenseKeyDisplay.ID != 0 {
			licenseKeyDisplayDim := p.licenseKeyDisplay.RawDimensions()
			licenseKeyDisplayW := licenseKeyDisplayDim[0]
			p.licenseKeyDisplay.X = p.Base.ScreenCenterX - int32(licenseKeyDisplayW/2)
			p.licenseKeyDisplay.Y = currentY
			currentY += int32(licenseKeyDisplayH) + licenseInfoMargin
		}

		// Email
		if p.emailDisplay.ID != 0 {
			emailDisplayDim := p.emailDisplay.RawDimensions()
			emailDisplayW := emailDisplayDim[0]
			p.emailDisplay.X = p.Base.ScreenCenterX - int32(emailDisplayW/2)
			p.emailDisplay.Y = currentY
			currentY += int32(emailDisplayH) + licenseInfoMargin
		}

		// Heading (top-most)
		p.licenseInfoHeading.X = p.Base.ScreenCenterX - int32(licenseHeadingW/2)
		p.licenseInfoHeading.Y = currentY
	}

	// 8) Get shader and render
	textShader, ok := sm.Get("text")
	if !ok {
		return fmt.Errorf("failed to fetch text shader")
	}
	color := colors.White

	p.Base.RenderTexture(textShader, p.title.ID, titlePos, titleDim, color)
	p.Base.RenderTexture(textShader, p.version.ID, versionPos, versionDim, color)
	p.Base.RenderTexture(textShader, p.prompt.ID, p.prompt.Position(), promptDim, color)
	p.Base.RenderTexture(textShader, p.note.ID, p.note.Position(), p.note.RawDimensions(), color)

	// Render display status
	p.Base.RenderTexture(textShader, p.displayStatus.ID, p.displayStatus.Position(), p.displayStatus.RawDimensions(), color)
	p.Base.RenderTexture(textShader, p.sdlDisplayStatus.ID, p.sdlDisplayStatus.Position(), p.sdlDisplayStatus.RawDimensions(), color)

	// Render license info if it exists
	if p.hasLicenseInfo {
		p.Base.RenderTexture(textShader, p.licenseInfoHeading.ID, p.licenseInfoHeading.Position(), p.licenseInfoHeading.RawDimensions(), color)
		if p.emailDisplay.ID != 0 {
			p.Base.RenderTexture(textShader, p.emailDisplay.ID, p.emailDisplay.Position(), p.emailDisplay.RawDimensions(), color)
		}
		if p.licenseKeyDisplay.ID != 0 {
			p.Base.RenderTexture(textShader, p.licenseKeyDisplay.ID, p.licenseKeyDisplay.Position(), p.licenseKeyDisplay.RawDimensions(), color)
		}
	}

	return nil
}

// Destroy cleans up page-specific resources.
func (p *Welcome) Destroy() error {
	gl.DeleteTextures(1, &p.title.ID)
	gl.DeleteTextures(1, &p.version.ID)
	gl.DeleteTextures(1, &p.prompt.ID)
	gl.DeleteTextures(1, &p.note.ID)
	gl.DeleteTextures(1, &p.displayStatus.ID)
	gl.DeleteTextures(1, &p.sdlDisplayStatus.ID)

	if p.hasLicenseInfo {
		gl.DeleteTextures(1, &p.licenseInfoHeading.ID)
		if p.emailDisplay.ID != 0 {
			gl.DeleteTextures(1, &p.emailDisplay.ID)
		}
		if p.licenseKeyDisplay.ID != 0 {
			gl.DeleteTextures(1, &p.licenseKeyDisplay.ID)
		}
	}

	return p.Base.Destroy()
}