package controllers

import (
	"fmt"
	"io/fs"
	"net/http"
	"path"
	"sort"
	"strings"

	"congo.gg/pkg/application"
)

// Source creates the source browser controller.
// sourceFS should embed the full Congo source tree.
func Source(sourceFS fs.FS) (string, *SourceController) {
	return "source", &SourceController{sourceFS: sourceFS}
}

type SourceController struct {
	application.BaseController
	sourceFS fs.FS

	// Per-request state (set in Handle via value receiver copy).
	entries []DirEntry
	file    *SourceFile
	reqPath string
}

type DirEntry struct {
	Name  string
	IsDir bool
	Path  string
	Size  string
}

type SourceFile struct {
	Name     string
	Path     string
	Content  string
	Lines    int
	LineNums []int
	Lang     string
}

func (c *SourceController) Setup(app *application.App) {
	c.BaseController.Setup(app)
	http.Handle("GET /source", app.Serve("source.html", nil))
	http.Handle("GET /source/{path...}", app.Serve("source.html", nil))
}

func (c SourceController) Handle(r *http.Request) application.Controller {
	c.Request = r

	p := r.PathValue("path")
	if p == "" {
		p = "."
	}
	c.reqPath = p

	info, err := fs.Stat(c.sourceFS, p)
	if err != nil {
		return &c
	}

	if info.IsDir() {
		c.entries = c.readDir(p)
	} else {
		c.file = c.readFile(p)
	}

	return &c
}

func (c *SourceController) Path() string {
	if c.reqPath == "." {
		return ""
	}
	return c.reqPath
}

func (c *SourceController) Breadcrumbs() []DirEntry {
	crumbs := []DirEntry{{Name: "congo", Path: ""}}
	if c.reqPath == "." {
		return crumbs
	}
	parts := strings.Split(c.reqPath, "/")
	for i, part := range parts {
		p := strings.Join(parts[:i+1], "/")
		crumbs = append(crumbs, DirEntry{Name: part, Path: p})
	}
	return crumbs
}

func (c *SourceController) Entries() []DirEntry {
	return c.entries
}

func (c *SourceController) File() *SourceFile {
	return c.file
}

func (c *SourceController) IsFile() bool {
	return c.file != nil
}

func (c *SourceController) NotFound() bool {
	return c.reqPath != "." && c.file == nil && c.entries == nil
}

func (c *SourceController) readDir(dirPath string) []DirEntry {
	entries, err := fs.ReadDir(c.sourceFS, dirPath)
	if err != nil {
		return nil
	}

	var dirs, files []DirEntry
	for _, e := range entries {
		var href string
		if dirPath == "." {
			href = e.Name()
		} else {
			href = dirPath + "/" + e.Name()
		}
		var size string
		if !e.IsDir() {
			if info, err := e.Info(); err == nil {
				size = formatSize(info.Size())
			}
		}
		entry := DirEntry{
			Name:  e.Name(),
			IsDir: e.IsDir(),
			Path:  href,
			Size:  size,
		}
		if e.IsDir() {
			dirs = append(dirs, entry)
		} else {
			files = append(files, entry)
		}
	}

	sort.Slice(dirs, func(i, j int) bool { return dirs[i].Name < dirs[j].Name })
	sort.Slice(files, func(i, j int) bool { return files[i].Name < files[j].Name })

	return append(dirs, files...)
}

func formatSize(bytes int64) string {
	if bytes < 1024 {
		return fmt.Sprintf("%d B", bytes)
	}
	kb := float64(bytes) / 1024
	if kb < 1024 {
		return fmt.Sprintf("%.1f KB", kb)
	}
	mb := kb / 1024
	return fmt.Sprintf("%.1f MB", mb)
}

func extToLang(name, ext string) string {
	switch ext {
	case ".go", ".mod", ".sum":
		return "go"
	case ".html", ".htm", ".tmpl":
		return "xml"
	case ".js", ".jsx", ".mjs":
		return "javascript"
	case ".css":
		return "css"
	case ".json":
		return "json"
	case ".md":
		return "markdown"
	case ".sh", ".bash":
		return "bash"
	case ".yaml", ".yml":
		return "yaml"
	}
	// Extensionless files
	switch name {
	case "Makefile":
		return "makefile"
	case "Dockerfile":
		return "dockerfile"
	}
	return "plaintext"
}

func (c *SourceController) readFile(filePath string) *SourceFile {
	content, err := fs.ReadFile(c.sourceFS, filePath)
	if err != nil {
		return nil
	}

	lines := strings.Count(string(content), "\n")
	if len(content) > 0 && content[len(content)-1] != '\n' {
		lines++
	}
	nums := make([]int, lines)
	for i := range nums {
		nums[i] = i + 1
	}

	return &SourceFile{
		Name:     path.Base(filePath),
		Path:     filePath,
		Content:  string(content),
		Lines:    lines,
		LineNums: nums,
		Lang:     extToLang(path.Base(filePath), path.Ext(filePath)),
	}
}