package ui

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

	"fyne.io/fyne/v2"
	fyneapp "fyne.io/fyne/v2/app"
	"fyne.io/fyne/v2/container"
	"fyne.io/fyne/v2/dialog"
	"fyne.io/fyne/v2/layout"
	"fyne.io/fyne/v2/storage"
	"fyne.io/fyne/v2/widget"
	appcore "github.com/veggiedefender/torrent-client/internal/app"
	"github.com/veggiedefender/torrent-client/internal/torrent"
	"github.com/veggiedefender/torrent-client/internal/torrentfile"
)

type desktopUI struct {
	controller *appcore.Controller
	app        fyne.App
	window     fyne.Window

	pathEntry        *widget.Entry
	downloadDirEntry *widget.Entry
	progress         *widget.ProgressBar
	phaseLabel       *widget.Label
	phaseMetricLabel *widget.Label
	messageLabel     *widget.Label
	errorLabel       *widget.Label
	nameLabel        *widget.Label
	sizeLabel        *widget.Label
	pieceLabel       *widget.Label
	pieceCountLabel  *widget.Label
	downloadedLabel  *widget.Label
	outputLabel      *widget.Label
	speedLabel       *widget.Label
	peerCountLabel   *widget.Label

	mu       sync.RWMutex
	trackers []torrent.TrackerStatus
	peers    []torrent.PeerStatus
	files    []torrentfile.File

	trackersTable *widget.Table
	peersTable    *widget.Table
	filesTable    *widget.Table

	stopRefresh chan struct{}
}

func Start(controller *appcore.Controller) {
	desktop := newDesktopUI(controller)
	desktop.window.ShowAndRun()
}

func newDesktopUI(controller *appcore.Controller) *desktopUI {
	a := fyneapp.NewWithID("github.com/veggiedefender/ztorrent")
	w := a.NewWindow("Ztorrent")
	w.Resize(fyne.NewSize(1200, 760))

	ui := &desktopUI{
		controller:       controller,
		app:              a,
		window:           w,
		stopRefresh:      make(chan struct{}),
		pathEntry:        widget.NewEntry(),
		downloadDirEntry: widget.NewEntry(),
		progress:         widget.NewProgressBar(),
		phaseLabel:       widget.NewLabel("Phase: idle"),
		phaseMetricLabel: widget.NewLabel("idle"),
		messageLabel:     widget.NewLabel(""),
		errorLabel:       widget.NewLabel(""),
		nameLabel:        widget.NewLabel("-"),
		sizeLabel:        widget.NewLabel("-"),
		pieceLabel:       widget.NewLabel("-"),
		pieceCountLabel:  widget.NewLabel("-"),
		downloadedLabel:  widget.NewLabel("0 / 0"),
		outputLabel:      widget.NewLabel("-"),
		speedLabel:       widget.NewLabel("0 B/s"),
		peerCountLabel:   widget.NewLabel("0"),
	}

	ui.pathEntry.SetPlaceHolder("/path/to/file.torrent")
	ui.downloadDirEntry.SetPlaceHolder("/path/to/download/folder")
	if home, err := os.UserHomeDir(); err == nil {
		ui.downloadDirEntry.SetText(home)
	}

	browseButton := widget.NewButton("Browse Torrent", ui.onBrowse)
	browseOutputButton := widget.NewButton("Browse Folder", ui.onBrowseOutputFolder)
	loadButton := widget.NewButton("Load Torrent", ui.onLoad)
	torrentRow := container.NewBorder(nil, nil, nil, browseButton, ui.pathEntry)
	outputRow := container.NewBorder(nil, nil, nil, container.NewHBox(browseOutputButton, loadButton), ui.downloadDirEntry)
	topRows := container.NewVBox(torrentRow, outputRow)

	metaGrid := container.NewGridWithColumns(4,
		wrapMetric("Name", ui.nameLabel),
		wrapMetric("Size (bytes)", ui.sizeLabel),
		wrapMetric("Piece length", ui.pieceLabel),
		wrapMetric("Completed pieces", ui.pieceCountLabel),
		wrapMetric("Downloaded", ui.downloadedLabel),
		wrapMetric("Speed", ui.speedLabel),
		wrapMetric("Output", ui.outputLabel),
		wrapMetric("Discovered peers", ui.peerCountLabel),
		wrapMetric("Phase", ui.phaseMetricLabel),
	)

	ui.trackersTable = ui.newTrackersTable()
	ui.peersTable = ui.newPeersTable()
	ui.filesTable = ui.newFilesTable()

	tabs := container.NewAppTabs(
		container.NewTabItem("Trackers", container.NewMax(ui.trackersTable)),
		container.NewTabItem("Peers", container.NewMax(ui.peersTable)),
		container.NewTabItem("Files", container.NewMax(ui.filesTable)),
	)

	statusColumn := container.NewVBox(
		ui.phaseLabel,
		ui.progress,
		ui.messageLabel,
		ui.errorLabel,
	)

	content := container.NewBorder(
		topRows,
		nil,
		nil,
		nil,
		container.NewVBox(
			statusColumn,
			layout.NewSpacer(),
			metaGrid,
			layout.NewSpacer(),
			tabs,
		),
	)

	w.SetContent(content)
	w.SetOnClosed(func() {
		close(ui.stopRefresh)
	})

	if len(os.Args) > 1 {
		ui.pathEntry.SetText(os.Args[1])
		ui.onLoad()
	}

	go ui.refreshLoop()
	return ui
}

func wrapMetric(name string, value fyne.CanvasObject) fyne.CanvasObject {
	return container.NewVBox(widget.NewLabel(name), value)
}

func (ui *desktopUI) onBrowse() {
	filter := storage.NewExtensionFileFilter([]string{".torrent"})
	fd := dialog.NewFileOpen(func(reader fyne.URIReadCloser, err error) {
		if err != nil {
			ui.setError(err.Error())
			return
		}
		if reader == nil {
			return
		}
		defer reader.Close()

		ui.pathEntry.SetText(reader.URI().Path())
	}, ui.window)
	fd.SetFilter(filter)
	fd.Show()
}

func (ui *desktopUI) onLoad() {
	path := strings.TrimSpace(ui.pathEntry.Text)
	if path == "" {
		ui.setError("select a .torrent file first")
		return
	}
	downloadRoot := strings.TrimSpace(ui.downloadDirEntry.Text)
	if downloadRoot == "" {
		ui.setError("select a download folder first")
		return
	}
	info, err := os.Stat(downloadRoot)
	if err != nil {
		ui.setError("download folder is not accessible: " + err.Error())
		return
	}
	if !info.IsDir() {
		ui.setError("download path must be a folder")
		return
	}

	ui.setMessage("Loading torrent...")
	ui.setError("")

	go func() {
		err := ui.controller.StartTorrent(path, downloadRoot)
		status := ui.controller.Status()
		ui.updateFromStatus(status)
		if err != nil {
			ui.setError(err.Error())
		} else {
			ui.setMessage("Loaded " + filepath.Base(path))
		}
	}()
}

func (ui *desktopUI) onBrowseOutputFolder() {
	fd := dialog.NewFolderOpen(func(uri fyne.ListableURI, err error) {
		if err != nil {
			ui.setError(err.Error())
			return
		}
		if uri == nil {
			return
		}
		ui.downloadDirEntry.SetText(uri.Path())
	}, ui.window)
	fd.Show()
}

func (ui *desktopUI) refreshLoop() {
	ticker := time.NewTicker(1200 * time.Millisecond)
	defer ticker.Stop()

	for {
		select {
		case <-ui.stopRefresh:
			return
		case <-ticker.C:
			ui.updateFromStatus(ui.controller.Status())
		}
	}
}

func (ui *desktopUI) updateFromStatus(status torrent.Status) {
	fyne.Do(func() {
		ui.progress.SetValue(status.Progress)
		ui.phaseLabel.SetText("Phase: " + status.Phase)
		ui.phaseMetricLabel.SetText(status.Phase)
		ui.nameLabel.SetText(status.Name)
		ui.sizeLabel.SetText(strconv.Itoa(status.Length))
		ui.pieceLabel.SetText(strconv.Itoa(status.PieceLength))
		if status.PieceCount > 0 {
			ui.pieceCountLabel.SetText(fmt.Sprintf("%d / %d", status.CompletedPieces, status.PieceCount))
		} else {
			ui.pieceCountLabel.SetText("-")
		}
		ui.downloadedLabel.SetText(fmt.Sprintf("%d / %d", status.DownloadedBytes, status.TotalBytes))
		ui.speedLabel.SetText(formatBytesRate(status.DownloadSpeed))
		ui.outputLabel.SetText(status.OutputPath)
		ui.peerCountLabel.SetText(strconv.Itoa(status.PeerCount))

		ui.mu.Lock()
		ui.trackers = append(ui.trackers[:0], status.Trackers...)
		ui.peers = append(ui.peers[:0], status.Peers...)
		ui.files = append(ui.files[:0], status.Files...)
		ui.mu.Unlock()

		ui.trackersTable.Refresh()
		ui.peersTable.Refresh()
		ui.filesTable.Refresh()

		if status.LastError != "" {
			ui.errorLabel.SetText(status.LastError)
		} else {
			ui.errorLabel.SetText("")
		}
	})
}

func formatBytesRate(bytesPerSec float64) string {
	if bytesPerSec < 0 {
		bytesPerSec = 0
	}
	units := []string{"B/s", "KB/s", "MB/s", "GB/s", "TB/s"}
	value := bytesPerSec
	unit := 0
	for value >= 1024 && unit < len(units)-1 {
		value /= 1024
		unit++
	}
	if unit == 0 {
		return fmt.Sprintf("%.0f %s", value, units[unit])
	}
	return fmt.Sprintf("%.2f %s", value, units[unit])
}

func (ui *desktopUI) setMessage(msg string) {
	fyne.Do(func() {
		ui.messageLabel.SetText(msg)
	})
}

func (ui *desktopUI) setError(msg string) {
	fyne.Do(func() {
		if msg == "" {
			ui.errorLabel.SetText("")
			return
		}
		ui.errorLabel.SetText("Error: " + msg)
	})
}

func (ui *desktopUI) newTrackersTable() *widget.Table {
	table := widget.NewTable(
		func() (int, int) {
			ui.mu.RLock()
			defer ui.mu.RUnlock()
			return len(ui.trackers) + 1, 4
		},
		func() fyne.CanvasObject {
			return widget.NewLabel("")
		},
		func(id widget.TableCellID, obj fyne.CanvasObject) {
			label := obj.(*widget.Label)
			if id.Row == 0 {
				switch id.Col {
				case 0:
					label.SetText("Tracker")
				case 1:
					label.SetText("State")
				case 2:
					label.SetText("Peers")
				case 3:
					label.SetText("Error")
				}
				return
			}

			ui.mu.RLock()
			defer ui.mu.RUnlock()
			tr := ui.trackers[id.Row-1]
			switch id.Col {
			case 0:
				label.SetText(tr.URL)
			case 1:
				label.SetText(tr.State)
			case 2:
				label.SetText(strconv.Itoa(tr.PeerCount))
			case 3:
				label.SetText(tr.Error)
			}
		},
	)
	table.SetColumnWidth(0, 420)
	table.SetColumnWidth(1, 90)
	table.SetColumnWidth(2, 70)
	table.SetColumnWidth(3, 420)
	return table
}

func (ui *desktopUI) newPeersTable() *widget.Table {
	table := widget.NewTable(
		func() (int, int) {
			ui.mu.RLock()
			defer ui.mu.RUnlock()
			return len(ui.peers) + 1, 6
		},
		func() fyne.CanvasObject {
			return widget.NewLabel("")
		},
		func(id widget.TableCellID, obj fyne.CanvasObject) {
			label := obj.(*widget.Label)
			if id.Row == 0 {
				switch id.Col {
				case 0:
					label.SetText("Address")
				case 1:
					label.SetText("Port")
				case 2:
					label.SetText("State")
				case 3:
					label.SetText("Pieces")
				case 4:
					label.SetText("Source tracker")
				case 5:
					label.SetText("Error")
				}
				return
			}

			ui.mu.RLock()
			defer ui.mu.RUnlock()
			peer := ui.peers[id.Row-1]
			switch id.Col {
			case 0:
				label.SetText(peer.Address)
			case 1:
				label.SetText(strconv.Itoa(int(peer.Port)))
			case 2:
				label.SetText(peer.State)
			case 3:
				label.SetText(strconv.Itoa(peer.DownloadedPieces))
			case 4:
				label.SetText(peer.Source)
			case 5:
				label.SetText(peer.Error)
			}
		},
	)
	table.SetColumnWidth(0, 170)
	table.SetColumnWidth(1, 80)
	table.SetColumnWidth(2, 100)
	table.SetColumnWidth(3, 70)
	table.SetColumnWidth(4, 310)
	table.SetColumnWidth(5, 440)
	return table
}

func (ui *desktopUI) newFilesTable() *widget.Table {
	table := widget.NewTable(
		func() (int, int) {
			ui.mu.RLock()
			defer ui.mu.RUnlock()
			return len(ui.files) + 1, 2
		},
		func() fyne.CanvasObject {
			return widget.NewLabel("")
		},
		func(id widget.TableCellID, obj fyne.CanvasObject) {
			label := obj.(*widget.Label)
			if id.Row == 0 {
				switch id.Col {
				case 0:
					label.SetText("File")
				case 1:
					label.SetText("Size")
				}
				return
			}

			ui.mu.RLock()
			defer ui.mu.RUnlock()
			file := ui.files[id.Row-1]
			switch id.Col {
			case 0:
				label.SetText(file.Path)
			case 1:
				label.SetText(fmt.Sprintf("%d", file.Length))
			}
		},
	)
	table.SetColumnWidth(0, 780)
	table.SetColumnWidth(1, 120)
	return table
}