package main

import (
	"embed"
	"encoding/base64"
	"encoding/json"
	"fmt"
	"io/fs"
	"log"
	"net/http"
	"os"
	"path/filepath"
	"sort"
	"strings"
	"time"
)

// ============================================================================
// 嵌入前端文件
// ============================================================================

//go:embed index.html
var content embed.FS

// ============================================================================
// 数据结构定义
// ============================================================================

// UploadRequest 前端发送的签名上传请求结构
type UploadRequest struct {
	Name  string `json:"name"`  // 签署人姓名
	Image string `json:"image"` // Base64 编码的签名图片
}

// UploadResponse 服务器返回的响应结构
type UploadResponse struct {
	Success bool   `json:"success"` // 是否成功
	Message string `json:"message"` // 提示信息
	Path    string `json:"path"`    // 文件保存路径
}

// LoginRequest 登录请求结构
type LoginRequest struct {
	Account  string `json:"account"`  // 账号
	Password string `json:"password"` // 密码
}

// LoginResponse 登录响应结构
type LoginResponse struct {
	Success bool   `json:"success"` // 是否成功
	Token   string `json:"token"`   // 认证令牌
	Message string `json:"message"` // 提示信息
}

// SignatureItem 签名文件信息结构
type SignatureItem struct {
	Name string `json:"name"` // 签署人姓名
	Path string `json:"path"` // 文件路径
	Date string `json:"date"` // 签名日期
	Size int64  `json:"size"` // 文件大小（字节）
}

// ============================================================================
// 全局变量
// ============================================================================

// 存储账号密码信息
var accountConfig struct {
	Account  string `json:"account"`  // 账号
	Password string `json:"password"` // 密码
}

// 存储有效的认证令牌，格式：令牌 -> 账号
var validTokens = make(map[string]string)

// Token 过期时间（24小时）
const tokenExpireDuration = 24 * time.Hour

// 存储令牌的创建时间
var tokenCreateTimes = make(map[string]time.Time)

// uploads 目录的绝对路径
var uploadsDir string

// ============================================================================
// 主函数
// ============================================================================

func main() {
	// 获取可执行文件所在目录
	execPath, err := os.Executable()
	if err != nil {
		log.Printf("获取可执行文件路径失败: %v，使用当前目录", err)
		execPath = filepath.Join(".", "placeholder")
	}
	execDir := filepath.Dir(execPath)

	// 初始化 uploads 目录的绝对路径
	uploadsDir = filepath.Join(execDir, "uploads")

	// 加载账号密码配置文件
	loadAccountConfig(execDir)

	// 注册路由
	setupRoutes()

	// 启动服务器
	port := ":10081"
	fmt.Println("========================================")
	fmt.Println("  电子签名归档系统 v2.0")
	fmt.Println("========================================")
	fmt.Printf("监听端口: %s\n", port)
	fmt.Printf("签名存储: %s\n", uploadsDir)
	fmt.Printf("访问地址: http://localhost%s\n", port)
	fmt.Println("========================================")

	if err := http.ListenAndServe(port, nil); err != nil {
		log.Fatal("服务器启动失败:", err)
	}
}

// ============================================================================
// 路由设置
// ============================================================================

// setupRoutes 注册所有 HTTP 路由
func setupRoutes() {
	// 主页面 - 从嵌入的文件系统提供前端页面
	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "text/html; charset=utf-8")
		data, err := content.ReadFile("index.html")
		if err != nil {
			http.Error(w, "系统错误: 页面文件丢失", 500)
			return
		}
		w.Write(data)
	})

	// 签名上传接口（无需认证）
	http.HandleFunc("/upload", uploadHandler)

	// 登录接口
	http.HandleFunc("/login", loginHandler)

	// 验证登录状态接口
	http.HandleFunc("/api/check-auth", checkAuthHandler)

	// 获取签名列表接口（需要认证）
	http.HandleFunc("/api/signatures", signaturesHandler)

	// 下载签名文件接口（需要认证）
	http.HandleFunc("/download", downloadHandler)
}

// ============================================================================
// 认证相关函数
// ============================================================================

// loadAccountConfig 从 pwd.json 加载账号密码配置
// 优先从可执行文件目录加载，如果找不到则从当前工作目录加载
func loadAccountConfig(execDir string) {
	// 尝试从可执行文件目录加载
	configPath := filepath.Join(execDir, "pwd.json")
	if err := loadConfigFromFile(configPath); err != nil {
		// 如果失败，尝试从当前工作目录加载
		configPath = filepath.Join(".", "pwd.json")
		if err := loadConfigFromFile(configPath); err != nil {
			log.Printf("警告: 未找到 pwd.json 配置文件，登录功能将不可用")
			return
		}
	}
	log.Printf("已加载账号配置: %s", configPath)
}

// loadConfigFromFile 从指定路径加载配置文件
func loadConfigFromFile(path string) error {
	data, err := os.ReadFile(path)
	if err != nil {
		return err
	}
	return json.Unmarshal(data, &accountConfig)
}

// generateToken 生成认证令牌
// 格式：base64(账号:时间戳)，简单但足够用于本地场景
func generateToken(account string) string {
	// 组合账号和时间戳
	raw := fmt.Sprintf("%s:%d", account, time.Now().UnixNano())
	// Base64 编码
	token := base64.StdEncoding.EncodeToString([]byte(raw))

	// 记录令牌创建时间
	validTokens[token] = account
	tokenCreateTimes[token] = time.Now()

	return token
}

// validateToken 验证令牌是否有效
// 返回：是否有效、对应的账号
func validateToken(token string) (bool, string) {
	if token == "" {
		return false, ""
	}

	// 检查令牌是否存在
	account, exists := validTokens[token]
	if !exists {
		return false, ""
	}

	// 检查令牌是否过期
	createTime, ok := tokenCreateTimes[token]
	if !ok || time.Since(createTime) > tokenExpireDuration {
		// 令牌已过期，删除它
		delete(validTokens, token)
		delete(tokenCreateTimes, token)
		return false, ""
	}

	return true, account
}

// cleanExpiredTokens 清理过期的令牌
func cleanExpiredTokens() {
	now := time.Now()
	for token, createTime := range tokenCreateTimes {
		if now.Sub(createTime) > tokenExpireDuration {
			delete(validTokens, token)
			delete(tokenCreateTimes, token)
		}
	}
}

// getAuthTokenFromRequest 从请求中提取认证令牌
// 支持从 Authorization 头或查询参数获取
func getAuthTokenFromRequest(r *http.Request) string {
	// 首先尝试从 Authorization 头获取
	authHeader := r.Header.Get("Authorization")
	if strings.HasPrefix(authHeader, "Bearer ") {
		return strings.TrimPrefix(authHeader, "Bearer ")
	}

	// 然后尝试从查询参数获取
	return r.URL.Query().Get("token")
}

// ============================================================================
// 路由处理函数
// ============================================================================

// loginHandler 处理登录请求
// POST /login - 验证账号密码，返回认证令牌
func loginHandler(w http.ResponseWriter, r *http.Request) {
	// 只允许 POST 方法
	if r.Method != http.MethodPost {
		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
		return
	}

	// 检查是否配置了账号密码
	if accountConfig.Account == "" {
		sendJSONResponse(w, false, "系统未配置登录账号", "")
		return
	}

	// 解析请求体
	var req LoginRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		sendJSONResponse(w, false, "无效的请求数据", "")
		return
	}

	// 去除前后空格
	req.Account = strings.TrimSpace(req.Account)
	req.Password = strings.TrimSpace(req.Password)

	// 验证账号密码
	if req.Account == "" || req.Password == "" {
		sendJSONResponse(w, false, "账号和密码不能为空", "")
		return
	}

	// 对比账号密码
	if req.Account != accountConfig.Account || req.Password != accountConfig.Password {
		log.Printf("登录失败: 账号 %s 密码错误", req.Account)
		sendJSONResponse(w, false, "账号或密码错误", "")
		return
	}

	// 登录成功，生成令牌
	token := generateToken(req.Account)
	log.Printf("登录成功: 账号 %s", req.Account)

	// 返回成功响应（使用 LoginResponse 结构）
	w.Header().Set("Content-Type", "application/json")
	resp := LoginResponse{
		Success: true,
		Token:   token,
		Message: "登录成功",
	}
	json.NewEncoder(w).Encode(resp)
}

// checkAuthHandler 检查认证状态
// GET /api/check-auth - 验证令牌是否有效
func checkAuthHandler(w http.ResponseWriter, r *http.Request) {
	token := getAuthTokenFromRequest(r)
	valid, account := validateToken(token)

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string]interface{}{
		"authenticated": valid,
		"account":       account,
	})
}

// uploadHandler 处理签名上传
// POST /upload - 接收 Base64 编码的签名图片并保存
func uploadHandler(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
		return
	}

	// 解析请求体
	var req UploadRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		sendJSONResponse(w, false, "无效的请求数据", "")
		return
	}

	// 验证姓名不为空
	req.Name = strings.TrimSpace(req.Name)
	if req.Name == "" {
		sendJSONResponse(w, false, "名字不能为空", "")
		return
	}

	// 验证签名数据不为空
	if req.Image == "" {
		sendJSONResponse(w, false, "签名数据为空", "")
		return
	}

	// 去除 Base64 前缀（data:image/png;base64,）
	b64data := req.Image
	if idx := strings.Index(b64data, ","); idx != -1 {
		b64data = b64data[idx+1:]
	}

	// 解码 Base64 数据
	imgBytes, err := base64.StdEncoding.DecodeString(b64data)
	if err != nil {
		sendJSONResponse(w, false, "图片数据解码失败", "")
		return
	}

	// 生成安全的文件名
	dateStr := time.Now().Format("2006-1-2")
	safeName := filepath.Base(req.Name)

	// 创建保存目录
	saveDir := filepath.Join("uploads", safeName)
	if err := os.MkdirAll(saveDir, 0755); err != nil {
		log.Printf("创建目录失败: %v", err)
		sendJSONResponse(w, false, "服务器存储错误", "")
		return
	}

	// 生成完整的文件路径
	fileName := fmt.Sprintf("%s+%s.png", safeName, dateStr)
	fullPath := filepath.Join(saveDir, fileName)

	// 写入文件
	if err := os.WriteFile(fullPath, imgBytes, 0644); err != nil {
		log.Printf("写入文件失败: %v", err)
		sendJSONResponse(w, false, "保存文件失败", "")
		return
	}

	log.Printf("已保存签名: %s", fullPath)
	sendJSONResponse(w, true, "签名保存成功！", fullPath)
}

// signaturesHandler 获取签名列表
// GET /api/signatures - 返回所有签名文件的信息（需要认证）
func signaturesHandler(w http.ResponseWriter, r *http.Request) {
	// 验证认证
	token := getAuthTokenFromRequest(r)
	valid, _ := validateToken(token)
	if !valid {
		w.Header().Set("Content-Type", "application/json")
		w.WriteHeader(http.StatusUnauthorized)
		json.NewEncoder(w).Encode(map[string]interface{}{
			"success": false,
			"message": "未登录或登录已过期",
		})
		return
	}

	// 收集所有签名文件
	signatures := collectSignatureFiles()

	// 返回结果
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string]interface{}{
		"success":    true,
		"signatures": signatures,
	})
}

// downloadHandler 下载签名文件
// GET /download?path=xxx - 下载指定的签名图片（需要认证）
func downloadHandler(w http.ResponseWriter, r *http.Request) {
	// 验证认证
	token := getAuthTokenFromRequest(r)
	valid, _ := validateToken(token)
	if !valid {
		w.Header().Set("Content-Type", "application/json")
		w.WriteHeader(http.StatusUnauthorized)
		json.NewEncoder(w).Encode(map[string]interface{}{
			"success": false,
			"message": "未登录或登录已过期",
		})
		return
	}

	// 获取文件路径参数
	filePath := r.URL.Query().Get("path")
	if filePath == "" {
		w.Header().Set("Content-Type", "application/json")
		w.WriteHeader(http.StatusBadRequest)
		json.NewEncoder(w).Encode(map[string]interface{}{
			"success": false,
			"message": "缺少文件路径参数",
		})
		return
	}

	// 安全检查：确保路径在 uploads 目录内，防止路径穿越攻击
	absPath, err := filepath.Abs(filePath)
	if err != nil {
		w.Header().Set("Content-Type", "application/json")
		w.WriteHeader(http.StatusBadRequest)
		json.NewEncoder(w).Encode(map[string]interface{}{
			"success": false,
			"message": "无效的文件路径",
		})
		return
	}

	// 获取 uploads 目录的绝对路径
	uploadsAbs, _ := filepath.Abs("uploads")
	if !strings.HasPrefix(absPath, uploadsAbs) {
		w.Header().Set("Content-Type", "application/json")
		w.WriteHeader(http.StatusForbidden)
		json.NewEncoder(w).Encode(map[string]interface{}{
			"success": false,
			"message": "无权访问该文件",
		})
		return
	}

	// 检查文件是否存在
	if _, err := os.Stat(absPath); os.IsNotExist(err) {
		w.Header().Set("Content-Type", "application/json")
		w.WriteHeader(http.StatusNotFound)
		json.NewEncoder(w).Encode(map[string]interface{}{
			"success": false,
			"message": "文件不存在",
		})
		return
	}

	// 设置响应头，触发浏览器下载
	fileName := filepath.Base(absPath)
	w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s\"", fileName))
	w.Header().Set("Content-Type", "image/png")

	// 提供文件
	http.ServeFile(w, r, absPath)
}

// ============================================================================
// 辅助函数
// ============================================================================

// sendJSONResponse 发送 JSON 格式的响应（上传接口专用）
func sendJSONResponse(w http.ResponseWriter, success bool, message string, path string) {
	w.Header().Set("Content-Type", "application/json")
	resp := UploadResponse{
		Success: success,
		Message: message,
		Path:    path,
	}
	json.NewEncoder(w).Encode(resp)
}

// collectSignatureFiles 收集 uploads 目录下所有签名文件
// 返回按修改时间倒序排列的签名文件列表
func collectSignatureFiles() []SignatureItem {
	var signatures []SignatureItem

	// 检查 uploads 目录是否存在
	if _, err := os.Stat("uploads"); os.IsNotExist(err) {
		return signatures
	}

	// 遍历 uploads 目录下的所有子目录（每个子目录对应一个签署人）
	err := filepath.Walk("uploads", func(path string, info fs.FileInfo, err error) error {
		if err != nil {
			return nil // 跳过错误的文件
		}

		// 只处理 .png 文件
		if !info.IsDir() && strings.HasSuffix(strings.ToLower(info.Name()), ".png") {
			// 从文件路径中提取签署人姓名（目录名）
			relPath, _ := filepath.Rel("uploads", path)
			parts := strings.SplitN(relPath, string(filepath.Separator), 2)
			name := ""
			if len(parts) > 0 {
				name = parts[0]
			}

			// 从文件名中提取日期
			// 文件名格式：<姓名>+<日期>.png
			baseName := strings.TrimSuffix(info.Name(), ".png")
			datePart := ""
			if idx := strings.LastIndex(baseName, "+"); idx != -1 {
				datePart = baseName[idx+1:]
			}

			signatures = append(signatures, SignatureItem{
				Name: name,
				Path: path,
				Date: datePart,
				Size: info.Size(),
			})
		}
		return nil
	})

	if err != nil {
		log.Printf("遍历签名目录失败: %v", err)
	}

	// 按修改时间倒序排列
	sort.Slice(signatures, func(i, j int) bool {
		fileInfoI, _ := os.Stat(signatures[i].Path)
		fileInfoJ, _ := os.Stat(signatures[j].Path)
		if fileInfoI == nil || fileInfoJ == nil {
			return false
		}
		return fileInfoI.ModTime().After(fileInfoJ.ModTime())
	})

	return signatures
}