package main

import (
	"database/sql"
	"embed"
	"fmt"
	"io/fs"
	"log"
	"net/http"

	"bilidown/internal/logger"
	"bilidown/internal/router"
	"bilidown/internal/util"

	_ "modernc.org/sqlite"
)

//go:embed all:static
var staticFiles embed.FS

const (
	HTTP_PORT = 8098      // HTTP 服务器端口
	HTTP_HOST = ""        // HTTP 服务器主机
	VERSION   = "v2.1.1" // 软件版本号
)

var urlLocal = fmt.Sprintf("http://127.0.0.1:%d", HTTP_PORT)
var ffmpegAvailable bool

func main() {
	ffmpegAvailable = checkFFmpeg()
	logger.FFmpegStatus(ffmpegAvailable)
	mustInitTables()
	mustRunServer()
	logger.ServerStarted(HTTP_PORT, VERSION)
	select {} // 保持运行
}

// checkFFmpeg 检测 ffmpeg 的安装情况，返回是否可用
func checkFFmpeg() bool {
	_, err := util.GetFFmpegPath()
	return err == nil
}

// mustRunServer 配置和启动 HTTP 服务器
func mustRunServer() {
	// 从嵌入的文件系统中获取静态文件
	staticFS, err := fs.Sub(staticFiles, "static")
	if err != nil {
		logger.Fatal("加载静态文件失败: " + err.Error())
	}
	// 前端静态文件
	http.Handle("/", http.FileServer(http.FS(staticFS)))
	// 后端 API 接口
	apiRouter := router.API()
	// 添加 FFmpeg 状态检查接口
	http.HandleFunc("/api/checkFFmpeg", func(w http.ResponseWriter, r *http.Request) {
		util.Res{Success: true, Data: map[string]bool{"available": ffmpegAvailable}}.Write(w)
	})
	http.Handle("/api/", http.StripPrefix("/api", apiRouter))
	// 启动 HTTP 服务器
	go func() {
		err := http.ListenAndServe(fmt.Sprintf("%s:%d", HTTP_HOST, HTTP_PORT), nil)
		if err != nil {
			log.Fatal("http.ListenAndServe:", err)
		}
	}()
}

// mustInitTables 初始化数据表
func mustInitTables() {
	db := util.MustGetDB()
	defer db.Close()

	if _, err := db.Exec(`CREATE TABLE IF NOT EXISTS "field" (
		"name" TEXT PRIMARY KEY NOT NULL,
		"value" TEXT
	)`); err != nil {
		logger.Fatal("创建 field 表失败: " + err.Error())
	}

	if _, err := db.Exec(`CREATE TABLE IF NOT EXISTS "log" (
		"id" integer NOT NULL PRIMARY KEY AUTOINCREMENT,
		"content" TEXT NOT NULL,
		"create_at" text NOT NULL DEFAULT CURRENT_TIMESTAMP
	)`); err != nil {
		logger.Fatal("创建 log 表失败: " + err.Error())
	}

	if _, err := db.Exec(`CREATE TABLE IF NOT EXISTS "task" (
		"id" integer NOT NULL PRIMARY KEY AUTOINCREMENT,
		"bvid" text NOT NULL,
		"cid" integer NOT NULL,
		"format" integer NOT NULL,
		"title" text NOT NULL,
		"owner" text NOT NULL,
		"cover" text NOT NULL,
		"status" text NOT NULL,
		"folder" text NOT NULL,
		"duration" integer NOT NULL,
		"download_type" text NOT NULL DEFAULT 'merge',
		"create_at" text NOT NULL DEFAULT CURRENT_TIMESTAMP
	)`); err != nil {
		logger.Fatal("创建 task 表失败: " + err.Error())
	}

	if _, err := util.GetCurrentFolder(db); err != nil {
		logger.Fatal("获取下载目录失败: " + err.Error())
	}

	if err := initHistoryTask(db); err != nil {
		logger.Fatal("初始化历史任务失败: " + err.Error())
	}

	// 添加可能缺失的列（用于数据库迁移）
	if err := addMissingColumns(db); err != nil {
		logger.Fatal("添加缺失列失败: " + err.Error())
	}

	logger.Info("数据库初始化完成")
}

// addMissingColumns 添加可能缺失的列（用于数据库迁移）
func addMissingColumns(db *sql.DB) error {
	util.SqliteLock.Lock()
	_, _ = db.Exec(`ALTER TABLE "task" ADD COLUMN "download_type" TEXT DEFAULT 'merge'`)
	_, _ = db.Exec(`UPDATE "task" SET "download_type" = 'merge' WHERE "download_type" IS NULL`)
	util.SqliteLock.Unlock()
	return nil
}

// initHistoryTask 将上一次程序运行时未完成的任务状态变为 error
func initHistoryTask(db *sql.DB) error {
	util.SqliteLock.Lock()
	result, err := db.Exec(`UPDATE "task" SET "status" = 'error' WHERE "status" IN ('waiting', 'running')`)
	util.SqliteLock.Unlock()
	if err != nil {
		return err
	}
	rowsAffected, _ := result.RowsAffected()
	if rowsAffected > 0 {
		logger.Infof("重置 %d 个未完成任务状态为 error", rowsAffected)
	}
	return nil
}