package main

import (
	"flag"
	"fmt"
	"io"
	"log"
	"net/http"
	"os"
	"path"
	"path/filepath"
	"strings"
	"time"

	"github.com/gin-gonic/gin"
	"golang.org/x/sync/singleflight"
)

// -----------------------------------------------------------------------------
// file-viewer CDN 资源本地缓存代理
//
// 前端 HTML 引用 /file-viewer/dist/flyfish-file-viewer-web-full.iife.js, 后端
// 先读本地缓存, 命中直接返回; 未命中从 unpkg 拉, 边写盘边流回客户端, 后续请求
// 全部走磁盘. vendor/ 资源同理按需拉取.
//
// 设计取舍:
//   - 缓存键 = URL 相对路径 (如 dist/foo.js / vendor/libarchive/worker-bundle.js).
//     升级 library 版本需手动 -rm 缓存目录, 避免旧版资源污染.
//   - 缓存目录不可写时降级为纯 CDN 透传, 不阻断预览功能.
//   - 缓存关闭 (-file-viewer-cache="") 时完全走 CDN, 行为与改造前一致.
// -----------------------------------------------------------------------------

var (
	fileViewerCDN      = flag.String("file-viewer-cdn", "https://unpkg.com/@file-viewer/web-full@3.0.0", "file-viewer CDN base URL")
	fileViewerCacheDir  = flag.String("file-viewer-cache", "./data/file-viewer", "file-viewer 资源缓存目录 (空字符串 = 禁用缓存, 全部 CDN 透传)")
	fileViewerCacheTTL = flag.Duration("file-viewer-ttl", 0, "缓存文件最大有效期 (0 = 永久, 仅在文件已存在时刷新 Content-Type)")
)

// 30 min 足够 330 KB 的 iife 与 vendor/ 下最大的 docx/pptx wasm (~50 MB) 在慢网下完成
var fileViewerHTTPClient = &http.Client{Timeout: 30 * time.Minute}

// fileViewerFetchGroup 按 cachePath 去重并发 fetch:
// 同 key 同一时刻只有一个 goroutine 真正去 CDN 拉, 其他并发请求阻塞等待,
// fetch 完成后从磁盘读 (文件已经落盘). 避免多个请求对同一文件重复上游拉取 + 写盘竞态.
var fileViewerFetchGroup singleflight.Group

// fileViewerProxy 处理 GET /file-viewer/*filepath.
//   1. 校验路径防 ../ 越界
//   2. 缓存命中 -> 直接读盘
//   3. 缓存未命中 -> 拉上游, 边写盘边流回
//   4. 缓存关闭 -> 直接透传到 CDN
func fileViewerProxy(c *gin.Context) {
	raw := c.Param("filepath")
	name, ok := validateFileViewerPath(raw)
	if !ok {
		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid path"})
		return
	}

	if *fileViewerCacheDir == "" {
		proxyFileViewer(c, name)
		return
	}

	cachePath := filepath.Join(*fileViewerCacheDir, filepath.FromSlash(name))

	// 命中: 直接读盘 (TTL > 0 且文件超过有效期则强制回源)
	if info, err := os.Stat(cachePath); err == nil && !info.IsDir() {
		if *fileViewerCacheTTL <= 0 || time.Since(info.ModTime()) < *fileViewerCacheTTL {
			c.Header("Cache-Control", "public, max-age=31536000, immutable")
			c.File(cachePath)
			return
		}
		log.Printf("[file-viewer] cache expired, refetching %s", name)
	}

	// 未命中: 拉上游 + 边写盘边流回
	fetchAndCache(c, cachePath, name)
}

// validateFileViewerPath 校验并清理 fileviewer 子路径, 防 ../ 越界.
// gin 的 *filepath wildcard 包含前导 '/', 先 strip 再清理.
// 先按 '/' 切分检查 `..` 分量 (path.Clean 会折叠中间 .., 仅靠它不够),
// 再 path.Clean 兜底处理 // / ./ 等冗余.
func validateFileViewerPath(raw string) (string, bool) {
	raw = strings.TrimPrefix(raw, "/")
	if raw == "" || strings.ContainsRune(raw, 0) {
		return "", false
	}
	for part := range strings.SplitSeq(raw, "/") {
		if part == ".." {
			return "", false
		}
	}
	clean := path.Clean(raw)
	if clean == "." || clean == "" || strings.HasPrefix(clean, "..") || strings.HasPrefix(clean, "/") {
		return "", false
	}
	return clean, true
}

// proxyFileViewer: 缓存关闭时直接透传到 CDN.
func proxyFileViewer(c *gin.Context, name string) {
	upstream := upstreamURL(name)
	resp, err := fileViewerHTTPClient.Get(upstream)
	if err != nil {
		log.Printf("[file-viewer] upstream fetch %s: %v", name, err)
		c.JSON(http.StatusBadGateway, gin.H{"error": "upstream fetch failed"})
		return
	}
	defer resp.Body.Close()

	if ct := resp.Header.Get("Content-Type"); ct != "" {
		c.Header("Content-Type", ct)
	}
	c.Status(resp.StatusCode)
	if _, err := io.Copy(c.Writer, resp.Body); err != nil {
		log.Printf("[file-viewer] stream %s: %v", name, err)
	}
}

// fetchAndCache: 通过 singleflight 按 cachePath 去重并发. 同一个 key 只有第一个
// 请求调 doFetchAndCache (拉 CDN + 边写盘边流回 writer 的 c.Writer); 其他并发
// 请求阻塞等待, 拿到结果后从磁盘读 (c.File).
//
// 注意: singleflight 的 shared=true 表示"结果被分享给多个 caller", 并不区分
// 首 caller 还是后续 caller. 这里用 closure 变量 isWriter 精确标识谁是写者:
//  - closure 被执行 = 写者 (响应已流回本 c.Writer, 直接返回)
//  - closure 未执行 = 等待者 (自己组装响应: 错误 -> 502, 成功 -> c.File)
func fetchAndCache(c *gin.Context, cachePath, name string) {
	isWriter := false
	_, err, _ := fileViewerFetchGroup.Do(cachePath, func() (interface{}, error) {
		isWriter = true
		return nil, doFetchAndCache(c, cachePath, name)
	})

	if isWriter {
		return
	}

	if err != nil {
		c.JSON(http.StatusBadGateway, gin.H{"error": err.Error()})
		return
	}
	c.Header("Cache-Control", "public, max-age=31536000, immutable")
	c.File(cachePath)
}

// doFetchAndCache: writer 路径专属 — 拉上游, 边写盘边流回传入的 c.Writer.
// 任何错误都会写入 c.Writer (502), 并返回 error 让 singleflight 把结果传给 waiter.
func doFetchAndCache(c *gin.Context, cachePath, name string) error {
	upstream := upstreamURL(name)
	resp, err := fileViewerHTTPClient.Get(upstream)
	if err != nil {
		log.Printf("[file-viewer] upstream fetch %s: %v", name, err)
		c.JSON(http.StatusBadGateway, gin.H{"error": "upstream fetch failed"})
		return err
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		log.Printf("[file-viewer] upstream %s returned %d", name, resp.StatusCode)
		c.JSON(http.StatusBadGateway, gin.H{"error": "upstream returned " + resp.Status})
		return fmt.Errorf("upstream returned %s", resp.Status)
	}

	if ct := resp.Header.Get("Content-Type"); ct != "" {
		c.Header("Content-Type", ct)
	}
	c.Header("Cache-Control", "public, max-age=31536000, immutable")
	c.Status(http.StatusOK)

	// 目录/文件创建失败 -> 降级透传, 不缓存
	if err := os.MkdirAll(filepath.Dir(cachePath), 0o755); err != nil {
		log.Printf("[file-viewer] mkdir cache dir: %v", err)
		_, _ = io.Copy(c.Writer, resp.Body)
		return err
	}
	f, err := os.Create(cachePath)
	if err != nil {
		log.Printf("[file-viewer] create cache file: %v", err)
		_, _ = io.Copy(c.Writer, resp.Body)
		return err
	}

	// 关键: MultiWriter 让客户端拿到的同时落盘, 用户感知零等待
	mw := io.MultiWriter(c.Writer, f)
	written, copyErr := io.Copy(mw, resp.Body)
	cErr := f.Close()

	if copyErr != nil || cErr != nil {
		_ = os.Remove(cachePath) // 写一半的文件清理掉, 下次重新拉
		if copyErr != nil {
			log.Printf("[file-viewer] copy %s: %v", name, copyErr)
		}
		if cErr != nil {
			log.Printf("[file-viewer] close %s: %v", name, cErr)
		}
		if copyErr != nil {
			return copyErr
		}
		return cErr
	}
	log.Printf("[file-viewer] cached %s (%d bytes)", name, written)
	return nil
}

func upstreamURL(name string) string {
	return strings.TrimRight(*fileViewerCDN, "/") + "/" + name
}