三、页面渲染、文件处理与session

// TemplateEngine 模板引擎接口
// 只有一个 Render 方法，负责将模板和数据渲染为最终内容
//
// 为什么不在接口里加 AddTemplate / LoadTemplate？
//   因为"管理模板"是具体模板引擎的事，和 Web 框架无关
//   接口要遵循单一职责原则——只管渲染，不管模板怎么来的
//
// 用户在创建 Server 时注入具体实现（如 GoTemplateEngine）
type TemplateEngine interface {
	// Render 渲染模板
	// 参数：
	//   tplName: 模板名称（用户在加载模板时指定的名字）
	//   data:     传入模板的数据（结构体、map 等）
	// 返回值：
	//   []byte: 渲染后的内容（如 HTML 页面）
	//   error:  渲染失败时的错误
	Render(tplName string, data interface{}) ([]byte, error)
}

package main

import (
	"os"
	"text/template"
)

// User 示例数据结构
// 模板里通过 .Name 和 .Age 访问这两个字段
type User struct {
	Name string
	Age  int
}

func main() {
	// Step 1: 创建模板实例
	// 传入模板名字 "user"，在多个模板组合使用时可以按名索引
	tpl := template.New("user")

	// Step 2: 解析模板内容（预编译）
	// {{.Name}} 表示访问传入数据的 Name 字段
	// {{.Age}} 表示访问传入数据的 Age 字段
	// . 代表当前作用域的当前对象（类似 Java 的 this、Python 的 self）
	tpl, err := tpl.Parse(`
姓名: {{.Name}}
年龄: {{.Age}}
`)
	if err != nil {
		panic(err)
	}

	// Step 3: 传入数据，渲染模板
	// 第二个参数是传给模板的数据，这里传一个 User 实例
	// 模板中的 . 就指向这个 User 实例
	err = tpl.Execute(os.Stdout, User{
		Name: "小明",
		Age:  18,
	})
	if err != nil {
		panic(err)
	}
}
// 输出：
// 姓名: 小明
// 年龄: 18

// 在模板中声明变量
// $xxx := some_value  （和 Go 语言类似，但用 $ 前缀）
// {{-  和  -}}  中的减号用于去除多余的空格和换行
// 注意：减号要和其他元素用空格分开

// 示例模板：
// {{- $name := .Name -}}    ← 声明变量 $name，去除前后空白
// 你好，{{$name}}            ← 使用变量

// 模板中的方法调用使用前缀表达式（不是 Go 的点号调用）
// 格式：调用者.方法名 参数1 参数2
// 注意：和 Go 语言的调用形式差异很大！

// Go 中：  user.Greet("hello")
// 模板中： {{.Greet "hello"}}

// 也可以调用内置方法：
// {{print .Name}}     ← 类似 fmt.Print
// {{len .Name}}       ← 获取字符串长度

// 使用 range 关键字遍历切片
// {{range $idx, $elem := .Methods}}
//   索引: {{$idx}}，元素: {{$elem}}
// {{end}}

// 注意：模板不支持 for...i... 循环，也不支持 for true 无限循环
// 如果需要 for i := 0; i < N; i++ 的效果，可以间接实现：

// 间接实现 for...i 循环
// Step 1: 创建一个足够大的切片
// Step 2: 对这个切片进行遍历
// $idx 就是我们需要的 i

// 示例模板：
// {{range $idx := .Count}}    ← .Count 是一个长度为 N 的切片
//   第 {{$idx}} 次
// {{end}}

// if-else 结构
// {{if .IsAdmin}}
//   管理员
// {{else if .IsVIP}}
//   VIP 用户
// {{else}}
//   普通用户
// {{end}}

// 逻辑运算符（前缀表达式）：
// {{and .IsAdmin .IsActive}}     ← 两个都为 true
// {{or .IsAdmin .IsVIP}}         ← 任一为 true
// {{not .IsDeleted}}             ← 取反

// 比较操作符也是前缀表达式：操作符 参数1 参数2
// {{eq .Status 200}}        ← 等于
// {{ne .Status 200}}        ← 不等于
// {{lt .Count 10}}          ← 小于 (less than)
// {{le .Count 10}}          ← 小于等于 (less or equal)
// {{gt .Count 10}}          ← 大于 (greater than)
// {{ge .Count 10}}          ← 大于等于 (greater or equal)

// Pipeline 类似 shell 中的管道，用 | 连接
// 前一个命令的输出作为后一个命令的输入

// 示例：
// {{.Name | printf "用户名: %s"}}     ← .Name 的值传给 printf
// {{.Name | len | printf "长度: %d"}} ← .Name → len → printf

// 可以将 pipeline 看做一系列命令的组合
// 单个命令可以是：声明变量、调用方法、访问字段等

package web

import (
	"bytes"         // bytes.Buffer 用于接收模板渲染结果
	"html/template" // Go 标准库的 HTML 模板引擎
	"io/fs"         // fs.FS 用于从文件系统加载模板
)

// GoTemplateEngine 基于 Go 标准库 html/template 的模板引擎实现
// 它实现了 TemplateEngine 接口
//
// 使用步骤：
//   1. 创建引擎：engine := NewGoTemplateEngine()
//   2. 加载模板：engine.LoadFromFS(fsys, "*.html")
//   3. 注入服务器：server := NewHTTPServer(":8081", WithTemplateEngine(engine))
//   4. 在路由中调用：ctx.Render("user.html", data)
type GoTemplateEngine struct {
	// templates 模板集合
	// Go 的 template.Template 可以持有多个命名模板
	// 通过模板名来索引和渲染
	templates *template.Template
}

// NewGoTemplateEngine 创建模板引擎实例
func NewGoTemplateEngine() *GoTemplateEngine {
	// template.New("") 创建一个空的模板集合
	// 后续通过 Parse 系列方法添加模板
	return &GoTemplateEngine{
		templates: template.New(""),
	}
}

// LoadFromFS 从文件系统加载模板
//
// 参数：
//   fsys: 实现了 fs.FS 接口的对象（可以是 embed.FS、os.DirFS 等）
//   patterns: 模板文件的匹配模式，如 "*.html" 或 "templates/*.html"
//
// 为什么用 fs.FS 而不是直接传文件路径？
//   因为 fs.FS 是抽象的文件系统接口
//   可以是真实的磁盘文件系统（os.DirFS）
//   也可以是嵌入的文件系统（go:embed）
//   这样设计更灵活
func (g *GoTemplateEngine) LoadFromFS(fsys fs.FS, patterns ...string) error {
	// template.ParseFS 从文件系统中解析模板
	// 会读取匹配 patterns 的所有文件，加载到 templates 中
	var err error
	g.templates, err = g.templates.ParseFS(fsys, patterns...)
	return err
}

// LoadFromFiles 从文件路径加载模板
//
// 参数：
//   filenames: 模板文件路径列表，如 "templates/user.html", "templates/home.html"
func (g *GoTemplateEngine) LoadFromFiles(filenames ...string) error {
	var err error
	// template.ParseFiles 从磁盘文件加载模板
	g.templates, err = g.templates.ParseFiles(filenames...)
	return err
}

// LoadFromStrings 从字符串加载模板
//
// 参数：
//   templates: 模板内容列表，每个元素是模板的文本内容
func (g *GoTemplateEngine) LoadFromStrings(templates ...string) error {
	var err error
	for _, t := range templates {
		// 逐个解析模板字符串
		_, err = g.templates.Parse(t)
		if err != nil {
			return err
		}
	}
	return nil
}

// Render 实现 TemplateEngine 接口
// 根据模板名找到对应模板，用 data 填充后返回渲染结果
//
// 参数：
//   tplName: 模板名称（加载时由文件名或用户指定）
//   data:     传入模板的数据
// 返回值：
//   []byte: 渲染后的 HTML 内容
//   error:  渲染失败时的错误
func (g *GoTemplateEngine) Render(tplName string, data interface{}) ([]byte, error) {
	// 创建一个 buffer 来接收渲染结果
	// 这里用 bytes.Buffer 而不是直接写 http.ResponseWriter
	// 是因为我们需要先拿到完整的渲染结果，再存到 ctx.RespData
	var buf bytes.Buffer

	// ExecuteTemplate 执行指定名称的模板
	// 参数1: 输出目标（这里是 buffer）
	// 参数2: 模板名称
	// 参数3: 传入模板的数据
	err := g.templates.ExecuteTemplate(&buf, tplName, data)
	if err != nil {
		return nil, err
	}

	// 返回渲染结果
	return buf.Bytes(), nil
}

package web

// ServerOption 是 HTTPServer 的可选配置项
// 采用 Option 模式，让用户可以按需配置服务器
// 不需要模板引擎的用户完全不感知它的存在
type ServerOption func(*HTTPServer)

// WithTemplateEngine 注入模板引擎
// 这是一个 Option 函数，返回一个闭包
//
// 使用示例：
//   engine := NewGoTemplateEngine()
//   engine.LoadFromFiles("templates/*.html")
//   server := NewHTTPServer(":8081", WithTemplateEngine(engine))
func WithTemplateEngine(engine TemplateEngine) ServerOption {
	return func(s *HTTPServer) {
		s.tplEngine = engine
	}
}

// HTTPServer 结构体新增字段
type HTTPServer struct {
	addr        string
	router
	middlewares []Middleware

	// tplEngine 模板引擎（可选）
	// 如果为 nil，调用 Render 方法会返回 error
	tplEngine TemplateEngine
}

// NewHTTPServer 创建服务器，支持可选配置
// addr: 监听地址，如 ":8081"
// opts: 可选配置（如注入模板引擎）
func NewHTTPServer(addr string, opts ...ServerOption) *HTTPServer {
	h := &HTTPServer{
		addr:   addr,
		router: newRouter(),
	}
	// 应用所有 Option
	for _, opt := range opts {
		opt(h)
	}
	return h
}

// Render 渲染模板并返回响应
// 如果服务器没有注入模板引擎，返回 error
//
// 参数：
//   tplName: 模板名称（如 "user.html"）
//   data:     传入模板的数据（结构体、map 等）
//
// 使用示例：
//   ctx.Render("user.html", user)
func (c *Context) Render(tplName string, data interface{}) error {
	// 检查是否注入了模板引擎
	if c.tplEngine == nil {
		return errors.New("web: 未注入模板引擎")
	}
	// 调用模板引擎渲染
	result, err := c.tplEngine.Render(tplName, data)
	if err != nil {
		return err
	}
	// 将渲染结果存到 RespData（不直接写网络）
	// 这样中间件可以在 flashResp 之前修改响应内容
	// 例如：如果状态码是 500，可以替换为错误页面
	c.RespData = result
	c.RespStatusCode = http.StatusOK
	// 默认设置 Content-Type 为 HTML
	c.Resp.Header().Set("Content-Type", "text/html; charset=utf-8")
	return nil
}

package main

import (
	"embed"
	"fmt"
	"net/http"
	"os"
	"web"
)

//go:embed templates/*
var templateFS embed.FS

func main() {
	// Step 1: 创建模板引擎
	engine := web.NewGoTemplateEngine()
	// 从嵌入的文件系统加载所有 .html 模板
	err := engine.LoadFromFS(templateFS, "templates/*.html")
	if err != nil {
		fmt.Println("加载模板失败:", err)
		os.Exit(1)
	}

	// Step 2: 创建服务器，注入模板引擎
	h := web.NewHTTPServer(":8081", web.WithTemplateEngine(engine))

	// Step 3: 注册路由
	h.Get("/user", func(ctx *web.Context) {
		// 准备模板数据
		user := struct {
			Name string
			Age  int
		}{
			Name: "小明",
			Age:  18,
		}
		// 渲染 user.html 模板，传入 user 数据
		err := ctx.Render("user.html", user)
		if err != nil {
			// 渲染失败，返回 500
			_ = ctx.JSON(500, map[string]string{"error": "渲染失败"})
		}
	})

	// Step 4: 启动服务器
	fmt.Println("Server started on :8081")
	_ = h.Start(":8081")
}

package main

import (
	"fmt"
	"os"
)

func main() {
	// ===== 读文件 =====
	// 方式一：ReadFile（最简单，一次性读取全部内容）
	// 适合小文件
	content, err := os.ReadFile("test.txt")
	if err != nil {
		fmt.Println("读取失败:", err)
		return
	}
	fmt.Println("文件内容:", string(content))

	// 方式二：Open（打开文件，返回 *os.File）
	// 适合需要逐行读取或大文件场景
	file, err := os.Open("test.txt")
	if err != nil {
		fmt.Println("打开失败:", err)
		return
	}
	defer file.Close() // 记得关闭！
	// 后续可以用 bufio.Scanner 逐行读取

	// ===== 打开文件（带选项）=====
	// OpenFile 可以指定 flag 和 mode
	// os.O_RDONLY: 只读
	// os.O_WRONLY: 只写
	// os.O_RDWR:   读写
	// os.O_CREATE:  如果不存在则创建
	// os.O_APPEND:  追加写入
	// os.O_TRUNC:   如果存在则清空
	file2, err := os.OpenFile("output.txt",
		os.O_WRONLY|os.O_CREATE|os.O_APPEND, // flag：写 | 创建 | 追加
		0644,                                 // mode：文件权限
	)
	if err != nil {
		fmt.Println("打开失败:", err)
		return
	}
	defer file2.Close()

	// ===== 创建文件 =====
	// Create 等价于 OpenFile(name, O_RDWR|O_CREATE|O_TRUNC, 0666)
	newFile, err := os.Create("newfile.txt")
	if err != nil {
		fmt.Println("创建失败:", err)
		return
	}
	defer newFile.Close()
}

import (
	"os"
	"io/fs"
)

// Flag 告诉操作系统你要怎么操作这个文件
// 用 os.O_ 前缀，多个 flag 用 | 连接
flag := os.O_RDONLY | os.O_CREATE  // 只读 + 如果不存在则创建

// Mode 控制文件权限
// 用 fs.ModeXXX 或直接用数字（如 0644）
mode := fs.ModePerm  // 等价于 0777
// 0644 = 拥有者可读写，其他人只读
// 0755 = 拥有者可读写执行，其他人可读执行

// 文件不存在的最常见原因：路径写错或使用了相对路径
// 相对路径是相对于"当前工作目录"，不是相对于源代码文件

// 查看当前工作目录
cwd, _ := os.Getwd()
fmt.Println("当前工作目录:", cwd)

// 解决思路：
// 1. 把绝对路径打印出来 DEBUG！
// 2. 不要猜！不要相信自己推测！

package web

import (
	"fmt"
	"io"
	"mime/multipart" // multipart 支持文件上传的解析
	"net/http"
	"os"             // os.Create 创建文件
	"path/filepath"  // filepath.Join 拼接路径
)

// FileUploader 文件上传处理器
// 不侵入 Context 和 HTTPServer，完全独立
//
// 使用示例：
//   uploader := &FileUploader{
//       FileField:   "file",                    // 表单中文件字段的 name
//       DstDir:      "./uploads",               // 保存目录
//   }
//   h.Post("/upload", uploader.Handle())
type FileUploader struct {
	// FileField 表单中文件字段的 name 属性
	// 对应 HTML: <input type="file" name="file">
	FileField string

	// DstDir 文件保存目录
	// 注意：目录必须已存在
	DstDir string
}

// Handle 返回一个 HandleFunc，用于注册到路由
func (f *FileUploader) Handle() HandleFunc {
	return func(ctx *Context) {
		// Step 1: 从请求中获取上传的文件
		// FormFile 返回 multipart.Form 中第一个指定 name 的文件
		// 返回值：文件句柄、文件头、错误
		file, header, err := ctx.Req.FormFile(f.FileField)
		if err != nil {
			// 获取失败（可能字段名不对，或请求中没有文件）
			_ = ctx.JSON(400, map[string]string{"error": "文件上传失败"})
			return
		}
		// 记得关闭文件句柄
		defer file.Close()

		// Step 2: 构造目标文件路径
		// filepath.Join 安全地拼接路径（自动处理分隔符）
		// header.Filename 是客户端上传的文件名
		dst := filepath.Join(f.DstDir, header.Filename)

		// Step 3: 创建目标文件
		dstFile, err := os.Create(dst)
		if err != nil {
			_ = ctx.JSON(500, map[string]string{"error": "创建文件失败"})
			return
		}
		defer dstFile.Close()

		// Step 4: 把上传的文件内容复制到目标文件
		// io.Copy 从 file 读取数据，写入 dstFile
		_, err = io.Copy(dstFile, file)
		if err != nil {
			_ = ctx.JSON(500, map[string]string{"error": "保存文件失败"})
			return
		}

		// Step 5: 返回成功响应
		_ = ctx.JSON(200, map[string]string{
			"msg":      "上传成功",
			"filename": header.Filename,
			"size":     fmt.Sprintf("%d bytes", header.Size),
		})
	}
}

func main() {
	h := NewHTTPServer(":8081")

	// 创建文件上传处理器
	uploader := &FileUploader{
		FileField: "file",    // 对应 HTML 中 <input name="file">
		DstDir:    "./uploads", // 保存到 ./uploads 目录
	}

	// 注册上传路由
	h.Post("/upload", uploader.Handle())

	_ = h.Start(":8081")
}

package web

import (
	"fmt"
	"net/http"
	"os"
	"path/filepath"
)

// FileDownloader 文件下载处理器
// 和 FileUploader 一样，不侵入框架，做成独立的 HandleFunc
//
// 使用示例：
//   downloader := &FileDownloader{Dir: "./downloads"}
//   h.Get("/download", downloader.Handle())
type FileDownloader struct {
	// Dir 文件所在目录
	Dir string
}

// Handle 返回文件下载的 HandleFunc
func (d *FileDownloader) Handle() HandleFunc {
	return func(ctx *Context) {
		// Step 1: 从查询参数获取文件名
		// 例如请求：GET /download?file=report.pdf
		filename := ctx.Query("file")
		if filename == "" {
			_ = ctx.JSON(400, map[string]string{"error": "缺少文件名参数"})
			return
		}

		// Step 2: 构造完整路径
		// 注意：这里不能直接拼接用户传入的路径！
		// 安全问题：如果用户传入 ../../etc/passwd，可能读取到敏感文件
		// 解决方案：只用文件名，去掉路径部分
		// filepath.Base 返回路径的最后一个元素（即纯文件名）
		filename = filepath.Base(filename)
		dst := filepath.Join(d.Dir, filename)

		// Step 3: 检查文件是否存在
		if _, err := os.Stat(dst); os.IsNotExist(err) {
			_ = ctx.JSON(404, map[string]string{"error": "文件不存在"})
			return
		}

		// Step 4: 设置下载相关的 HTTP 响应头
		// Content-Disposition: attachment 表示这是附件（浏览器会触发下载）
		// filename 指定下载后的默认文件名
		ctx.Resp.Header().Set("Content-Disposition",
			fmt.Sprintf("attachment; filename=\"%s\"", filename))
		// Content-Type: octet-stream 表示通用的二进制文件
		// 如果知道确切类型，可以换成更具体的，如 image/jpeg、application/pdf
		ctx.Resp.Header().Set("Content-Type", "application/octet-stream")
		// Content-Transfer-Encoding: binary 表示直接传输二进制
		ctx.Resp.Header().Set("Content-Transfer-Encoding", "binary")

		// Step 5: 读取文件并写入响应
		// http.ServeFile 是标准库提供的文件服务方法
		// 它会自动设置 Content-Length、支持 Range 请求（断点续传）
		http.ServeFile(ctx.Resp, ctx.Req, dst)
	}
}

func main() {
	h := NewHTTPServer(":8081")

	// 创建文件下载处理器
	downloader := &FileDownloader{Dir: "./downloads"}

	// 注册下载路由
	h.Get("/download", downloader.Handle())

	_ = h.Start(":8081")
}

package web

import (
	"fmt"
	"net/http"
	"os"
	"path/filepath"
	"strconv"        // strconv.Itoa 把数字转为字符串
	"strings"
	"sync"           // sync.RWMutex 读写锁保护并发缓存
)

// StaticResourceHandler 静态资源处理器
// 采用 Option 模式，允许用户自定义配置
//
// 使用示例：
//   handler := NewStaticResourceHandler(
//       WithStaticDir("./static"),
//       WithCacheMaxAge(3600),  // 缓存1小时
//   )
//   h.Get("/static/*", handler.Handle())
type StaticResourceHandler struct {
	// dir 静态资源目录
	dir string

	// cache 内存缓存（可选）
	// key: 文件路径，value: 文件内容
	// 如果不启用缓存，每次都从磁盘读取
	cache       map[string][]byte
	cacheEnable bool
	cacheMutex  sync.RWMutex // 读写锁，保护并发安全的缓存读写

	// maxAge 浏览器缓存时间（秒）
	// 对应 Cache-Control: max-age=xxx
	maxAge int
}

// StaticResourceOption 静态资源处理器的配置选项
type StaticResourceOption func(*StaticResourceHandler)

// WithStaticDir 设置静态资源目录
func WithStaticDir(dir string) StaticResourceOption {
	return func(h *StaticResourceHandler) {
		h.dir = dir
	}
}

// WithCache 启用内存缓存
func WithCache() StaticResourceOption {
	return func(h *StaticResourceHandler) {
		h.cacheEnable = true
		h.cache = make(map[string][]byte)
	}
}

// WithCacheMaxAge 设置浏览器缓存时间（秒）
func WithCacheMaxAge(maxAge int) StaticResourceOption {
	return func(h *StaticResourceHandler) {
		h.maxAge = maxAge
	}
}

// NewStaticResourceHandler 创建静态资源处理器
func NewStaticResourceHandler(opts ...StaticResourceOption) *StaticResourceHandler {
	// 默认配置
	h := &StaticResourceHandler{
		dir:    "./static",
		maxAge: 0, // 默认不缓存
	}
	// 应用用户传入的配置
	for _, opt := range opts {
		opt(h)
	}
	return h
}

// Handle 返回静态资源处理的 HandleFunc
// 采用 RESTful 设计：路径的最后一截是目标文件名
// 例如 /static/css/style.css → 读取 dir/css/style.css
func (h *StaticResourceHandler) Handle() HandleFunc {
	return func(ctx *Context) {
		// Step 1: 从 URL 路径中提取文件路径
		// 例如请求路径 /static/css/style.css
		// 去掉 /static 前缀，得到 css/style.css
		reqPath := ctx.Req.URL.Path

		// 安全处理：去掉路径中的 .. 防止目录穿越攻击
		// filepath.Clean 会规范化路径，如 a/../b → b
		reqPath = filepath.Clean(reqPath)

		// Step 2: 构造完整文件路径
		fullPath := filepath.Join(h.dir, reqPath)

		// Step 3: 如果启用了内存缓存，先查缓存
		if h.cacheEnable {
			// 用读锁查缓存（允许多个 goroutine 同时读）
			h.cacheMutex.RLock()
			data, ok := h.cache[fullPath]
			h.cacheMutex.RUnlock()

			if ok {
				// 缓存命中，直接返回缓存数据
				h.writeResponse(ctx, fullPath, data)
				return
			}
		}

		// Step 4: 缓存未命中，从磁盘读取文件
		data, err := os.ReadFile(fullPath)
		if err != nil {
			// 文件不存在
			ctx.RespStatusCode = http.StatusNotFound
			ctx.RespData = []byte("404 Not Found")
			return
		}

		// Step 5: 如果启用了缓存，写入缓存
		if h.cacheEnable {
			// 用写锁写入缓存（同一时刻只允许一个 goroutine 写）
			h.cacheMutex.Lock()
			h.cache[fullPath] = data
			h.cacheMutex.Unlock()
		}

		// Step 6: 返回文件内容
		h.writeResponse(ctx, fullPath, data)
	}
}

// writeResponse 设置响应头并写入文件内容
func (h *StaticResourceHandler) writeResponse(ctx *Context, filePath string, data []byte) {
	// 根据文件扩展名设置 Content-Type
	// 例如 .css → text/css，.js → application/javascript
	ext := filepath.Ext(filePath)
	contentType := getContentType(ext)
	ctx.Resp.Header().Set("Content-Type", contentType)

	// 设置浏览器缓存
	if h.maxAge > 0 {
		ctx.Resp.Header().Set("Cache-Control",
			"public, max-age="+strconv.Itoa(h.maxAge))
	}

	// 写入响应数据
	ctx.RespData = data
	ctx.RespStatusCode = http.StatusOK
}

// getContentType 根据文件扩展名返回 Content-Type
func getContentType(ext string) string {
	switch strings.ToLower(ext) {
	case ".html", ".htm":
		return "text/html; charset=utf-8"
	case ".css":
		return "text/css; charset=utf-8"
	case ".js":
		return "application/javascript; charset=utf-8"
	case ".json":
		return "application/json; charset=utf-8"
	case ".png":
		return "image/png"
	case ".jpg", ".jpeg":
		return "image/jpeg"
	case ".gif":
		return "image/gif"
	case ".svg":
		return "image/svg+xml"
	case ".webp":
		return "image/webp"
	case ".ico":
		return "image/x-icon"
	case ".pdf":
		return "application/pdf"
	case ".woff":
		return "font/woff"
	case ".woff2":
		return "font/woff2"
	default:
		return "application/octet-stream"
	}
}

func main() {
	h := NewHTTPServer(":8081")

	// 创建静态资源处理器（启用缓存，浏览器缓存1小时）
	staticHandler := NewStaticResourceHandler(
		WithStaticDir("./static"),
		WithCache(),        // 启用内存缓存
		WithCacheMaxAge(3600), // 浏览器缓存1小时
	)

	// 注册静态资源路由
	// 假设用户访问 /static/css/style.css，会读取 ./static/css/style.css
	h.Get("/static/*", staticHandler.Handle())

	_ = h.Start(":8081")
}

// 安全问题一：路径穿越攻击
// 黑客可能传入类似 ../../etc/passwd 的路径，直接读取服务器上的敏感文件
//
// 防御措施：
// 1. 使用 filepath.Base() 只取文件名部分，去掉路径
// 2. 使用 path.Clean() 规范化路径
// 3. 不支持复杂路径匹配（如 /img/* 匹配任意多段路径）

// 安全问题二：为什么静态资源不支持 /img/a/b/c/pic.jpg
// 而目标文件放在 a/b/c 目录下？
// 因为 /img/* 这种匹配机制如果支持多段路径，
// 黑客可以用 /img/../../../etc/passwd 访问任意文件

package session

import (
	"context"
	"fmt"           // fmt.Errorf 创建错误
	"sync"          // sync.RWMutex 读写锁保护并发访问
	"time"
)

// Session Session 本体，存储用户数据
// 它代表一个用户的会话，包含 session id、过期时间和键值对数据
//
// 使用方式：
//   sess.Get("user_id")       // 读取数据
//   sess.Set("user_id", 123)  // 写入数据
type Session struct {
	// id Session 的唯一标识
	// 用户登录成功后，服务器生成一个唯一的 id
	// 后续请求中通过这个 id 找到对应的 Session
	id string

	// values 存储用户数据
	// 例如登录后存入 user_id、role 等
	values map[string]any

	// expireAt 过期时间
	// 超过这个时间，Session 自动失效，用户需要重新登录
	expireAt time.Time
}

// Get 读取数据
// 返回 any 类型，调用方需要自行做类型断言
func (s *Session) Get(key string) any {
	return s.values[key]
}

// Set 写入数据
func (s *Session) Set(key string, val any) {
	s.values[key] = val
}

// ID 返回 session id
func (s *Session) ID() string {
	return s.id
}

// IsExpired 检查是否已过期
func (s *Session) IsExpired() bool {
	// 如果当前时间在 expireAt 之后，说明已过期
	return time.Now().After(s.expireAt)
}

// Refresh 刷新过期时间（续命）
// 用户持续活跃时，应该延长 Session 的有效期
func (s *Session) Refresh(expire time.Duration) {
	s.expireAt = time.Now().Add(expire)
}

// Store Session 管理器接口
// 负责创建、查找、销毁 Session
// 不同实现可以存储在内存、Redis、MySQL 等
//
// 这个接口对应 Beego 的 Provider，或 gorilla/Gin/Echo 的 Store
type Store interface {
	// Create 创建一个新的 Session
	// 参数 sessID: 由调用方生成的唯一 session id
	// 参数 expire: 过期时间
	// 返回创建好的 Session 实例
	Create(ctx context.Context, sessID string, expire time.Duration) (*Session, error)

	// Find 根据 session id 查找 Session
	// 如果找不到或已过期，返回 error
	Find(ctx context.Context, sessID string) (*Session, error)

	// Delete 销毁 Session（用户退出登录时调用）
	Delete(ctx context.Context, sessID string) error

	// Save 保存 Session 数据
	// 有些实现（如 gorilla）是延迟写入的，需要显式调用 Save
	// 注意：本次实现不使用延迟写入，Set 直接写入存储
	Save(ctx context.Context, sess *Session) error
}

// MemoryStore 基于内存的 Store 实现
// 适合单机应用或开发测试环境
// 生产环境建议使用 RedisStore（数据不丢失，支持多实例共享）
type MemoryStore struct {
	// sessions 存储所有活跃的 Session
	// key: session id，value: Session 指针
	sessions map[string]*Session

	// mutex 读写锁，保护 sessions 的并发访问
	// Web 服务器是并发的，多个请求可能同时读写 sessions
	mutex sync.RWMutex
}

// NewMemoryStore 创建内存存储
func NewMemoryStore() *MemoryStore {
	return &MemoryStore{
		sessions: make(map[string]*Session),
	}
}

// Create 实现 Store 接口
func (m *MemoryStore) Create(ctx context.Context, sessID string, expire time.Duration) (*Session, error) {
	// 创建 Session 实例
	sess := &Session{
		id:       sessID,
		values:   make(map[string]any),
		expireAt: time.Now().Add(expire),
	}

	// 用写锁保护写入操作
	m.mutex.Lock()
	m.sessions[sessID] = sess
	m.mutex.Unlock()

	return sess, nil
}

// Find 实现 Store 接口
func (m *MemoryStore) Find(ctx context.Context, sessID string) (*Session, error) {
	// 用读锁保护读取操作（允许多个 goroutine 同时读）
	m.mutex.RLock()
	sess, ok := m.sessions[sessID]
	m.mutex.RUnlock()

	if !ok {
		// Session 不存在
		return nil, fmt.Errorf("session not found")
	}

	// 检查是否过期
	if sess.IsExpired() {
		// 过期了，删除它
		m.mutex.Lock()
		delete(m.sessions, sessID)
		m.mutex.Unlock()
		return nil, fmt.Errorf("session expired")
	}

	return sess, nil
}

// Delete 实现 Store 接口
func (m *MemoryStore) Delete(ctx context.Context, sessID string) error {
	m.mutex.Lock()
	delete(m.sessions, sessID)
	m.mutex.Unlock()
	return nil
}

// Save 实现 Store 接口
// 因为 MemoryStore 是直接在内存操作的，Set 时就已经写入了
// 所以 Save 这里什么都不做
func (m *MemoryStore) Save(ctx context.Context, sess *Session) error {
	return nil
}

package session

import (
	"context"
	"fmt"           // fmt.Errorf 创建错误
	"net/http"
)

// Propagator session id 传递器
// 负责在 HTTP 请求/响应中注入和提取 session id
//
// 不同的实现可以把 session id 放在不同的位置：
//   - Cookie（最常见）
//   - Header
//   - URL 参数
//
// 理论上可以拆成两个接口（Inject 和 Extract），
// 但因为它们总是成对出现（放 Cookie 就从 Cookie 取），
// 所以合并成一个接口
type Propagator interface {
	// Inject 将 session id 注入到 HTTP 响应中
	// 例如：设置 Set-Cookie 响应头
	// 在用户登录成功后调用
	Inject(ctx context.Context, w http.ResponseWriter, sessID string) error

	// Extract 从 HTTP 请求中提取 session id
	// 例如：从 Cookie 中读取 session id
	// 在每次请求到来时调用
	Extract(ctx context.Context, r *http.Request) (string, error)
}

// CookiePropagator 基于 Cookie 的 Propagator 实现
// 这是最常用的方案，浏览器会自动在后续请求中携带 Cookie
//
// 使用示例：
//   prop := NewCookiePropagator("sessid", 3600)
//   // session id 会存在名为 "sessid" 的 Cookie 中
//   // Cookie 有效期为 3600 秒
type CookiePropagator struct {
	// cookieName 存放 session id 的 Cookie 名
	// 常见名称：sessid、session_id、JSESSIONID
	cookieName string

	// cookieMaxAge Cookie 的过期时间（秒）
	// 0 表示会话级 Cookie（浏览器关闭后失效）
	cookieMaxAge int
}

// NewCookiePropagator 创建 Cookie 传递器
func NewCookiePropagator(cookieName string, maxAge int) *CookiePropagator {
	return &CookiePropagator{
		cookieName:  cookieName,
		cookieMaxAge: maxAge,
	}
}

// Inject 将 session id 写入 Cookie
func (c *CookiePropagator) Inject(ctx context.Context, w http.ResponseWriter, sessID string) error {
	// 创建一个 Cookie 并设置到响应头
	http.SetCookie(w, &http.Cookie{
		Name:     c.cookieName,     // Cookie 名
		Value:    sessID,           // session id
		MaxAge:   c.cookieMaxAge,   // 过期时间
		Path:     "/",              // 对所有路径生效
		HttpOnly: true,             // 禁止 JavaScript 读取（防 XSS）
		Secure:   false,            // 生产环境应设为 true（只在 HTTPS 传输）
		SameSite: http.SameSiteLaxMode, // 防止 CSRF 攻击
	})
	return nil
}

// Extract 从请求的 Cookie 中提取 session id
func (c *CookiePropagator) Extract(ctx context.Context, r *http.Request) (string, error) {
	// 从请求中读取指定名称的 Cookie
	cookie, err := r.Cookie(c.cookieName)
	if err != nil {
		if err == http.ErrNoCookie {
			// 用户没有发送 Cookie（可能未登录，或禁用了 Cookie）
			return "", fmt.Errorf("no session cookie")
		}
		return "", err
	}
	// 返回 Cookie 的值（即 session id）
	return cookie.Value, nil
}

// HeaderPropagator 基于 HTTP Header 的 Propagator 实现
// 当用户禁用了 Cookie 时，可以使用 Header 方案
//
// 使用示例：
//   prop := NewHeaderPropagator("X-Session-Id")
//   // session id 会放在名为 "X-Session-Id" 的请求头中
type HeaderPropagator struct {
	// headerName 存放 session id 的 Header 名
	headerName string
}

// NewHeaderPropagator 创建 Header 传递器
func NewHeaderPropagator(headerName string) *HeaderPropagator {
	return &HeaderPropagator{headerName: headerName}
}

// Inject 将 session id 写入响应头
func (h *HeaderPropagator) Inject(ctx context.Context, w http.ResponseWriter, sessID string) error {
	// 在响应头中设置 session id
	// 客户端需要自己保存这个值，并在后续请求中放到请求头里
	w.Header().Set(h.headerName, sessID)
	return nil
}

// Extract 从请求头中提取 session id
func (h *HeaderPropagator) Extract(ctx context.Context, r *http.Request) (string, error) {
	// 从请求头中读取
	sessID := r.Header.Get(h.headerName)
	if sessID == "" {
		return "", fmt.Errorf("no session header")
	}
	return sessID, nil
}

package session

import (
	"context"
	"crypto/rand"
	"encoding/hex"
	"net/http"
	"time"
)

// Manager Session 管理器
// 这是用户唯一需要直接使用的结构体
// 它内部组合了 Store（管理 Session 生命周期）和 Propagator（传递 session id）
//
// 使用示例：
//   manager := NewManager(
//       NewMemoryStore(),
//       NewCookiePropagator("sessid", 3600),
//       time.Hour, // Session 有效期 1 小时
//   )
type Manager struct {
	// store Session 存储器
	// 负责创建、查找、销毁 Session
	store Store

	// propagator session id 传递器
	// 负责在 HTTP 请求/响应中注入和提取 session id
	propagator Propagator

	// expire Session 的默认有效期
	// 创建 Session 时使用
	expire time.Duration
}

// NewManager 创建 Session 管理器
//
// 参数：
//   store: Session 存储实现（如 MemoryStore、RedisStore）
//   propagator: session id 传递方式（如 CookiePropagator）
//   expire: Session 有效期
func NewManager(store Store, propagator Propagator, expire time.Duration) *Manager {
	return &Manager{
		store:      store,
		propagator: propagator,
		expire:     expire,
	}
}

// GenerateSessionID 生成随机的 session id
// 使用 crypto/rand 生成安全的随机字符串
//
// 为什么不简单用时间戳或自增 ID？
//   因为那些容易被猜到，攻击者可以伪造 session id
//   用 crypto/rand 生成的随机字符串不可预测
func GenerateSessionID() string {
	// 生成 16 字节的随机数据
	b := make([]byte, 16)
	_, _ = rand.Read(b)
	// 转为十六进制字符串（32 个字符）
	return hex.EncodeToString(b)
}

// InitSession 创建新 Session 并注入到响应中
// 在用户登录成功后调用
//
// 返回创建的 Session，用户可以通过 Set 方法存入数据
func (m *Manager) InitSession(ctx context.Context, w http.ResponseWriter) (*Session, error) {
	// Step 1: 生成唯一的 session id
	sessID := GenerateSessionID()

	// Step 2: 通过 Store 创建 Session
	sess, err := m.store.Create(ctx, sessID, m.expire)
	if err != nil {
		return nil, err
	}

	// Step 3: 通过 Propagator 把 session id 注入到响应中
	// 例如设置 Cookie，让浏览器在后续请求中自动带上
	err = m.propagator.Inject(ctx, w, sessID)
	if err != nil {
		return nil, err
	}

	return sess, nil
}

// GetSession 从请求中提取 session id，查找 Session
// 在每次请求时调用，获取当前用户的 Session
//
// 如果用户未登录或 Session 已过期，返回 error
func (m *Manager) GetSession(ctx context.Context, r *http.Request) (*Session, error) {
	// Step 1: 从请求中提取 session id
	sessID, err := m.propagator.Extract(ctx, r)
	if err != nil {
		// 提取失败（可能没有 Cookie，或 Header 中没有 session id）
		return nil, err
	}

	// Step 2: 通过 Store 查找 Session
	sess, err := m.store.Find(ctx, sessID)
	if err != nil {
		// 找不到或已过期
		return nil, err
	}

	// Step 3: 刷新过期时间（续命）
	// 用户持续活跃，Session 应该保持有效
	sess.Refresh(m.expire)

	return sess, nil
}

// Logout 销毁 Session（用户退出登录时调用）
func (m *Manager) Logout(ctx context.Context, r *http.Request) error {
	// Step 1: 从请求中提取 session id
	sessID, err := m.propagator.Extract(ctx, r)
	if err != nil {
		return err
	}

	// Step 2: 从 Store 中删除 Session
	return m.store.Delete(ctx, sessID)
}

// Context 结构体中的新增字段（之前章节已有定义，这里回顾）

type Context struct {
	// ... 其他字段（Req、Resp、PathParams 等）

	// UserValues 用户在中间件和业务逻辑之间传递自定义数据
	//
	// 为什么不用 http.Request 的 context.Context 来传递？
	//   因为 context.Context 有个特性：父亲 context 无法访问子 context 的内容
	//   而且每次 r.WithContext() 都会拷贝 Request，有性能开销
	//
	// 为什么初始化为 nil 而不是 make(map[string]any, 8)？
	//   因为多数用户可能用不上。即便用得上，不同的人也需要不同的容量
	//   为了规避不必要的内存分配，将初始化交给用户
	//
	// 使用示例（认证中间件）：
	//   if ctx.UserValues == nil {
	//       ctx.UserValues = make(map[string]any)
	//   }
	//   ctx.UserValues["user_id"] = sess.Get("user_id")
	//
	// 使用示例（业务函数）：
	//   userID := ctx.UserValues["user_id"]
	UserValues map[string]any
}

package main

import (
	"context"
	"fmt"
	"net/http"
	"time"
	"web"
	"web/session"
)

func main() {
	// Step 1: 创建 Session 管理器
	// 使用内存存储 + Cookie 传递 + 1 小时有效期
	manager := session.NewManager(
		session.NewMemoryStore(),
		session.NewCookiePropagator("sessid", 3600),
		time.Hour,
	)

	h := web.NewHTTPServer(":8081")

	// Step 2: 注册登录路由
	h.Post("/login", func(ctx *web.Context) {
		// 模拟登录验证（实际应查数据库）
		username := ctx.PostForm("username")
		password := ctx.PostForm("password")
		if username != "admin" || password != "123456" {
			_ = ctx.JSON(401, map[string]string{"error": "用户名或密码错误"})
			return
		}

		// 登录成功，创建 Session
		sess, err := manager.InitSession(context.Background(), ctx.Resp)
		if err != nil {
			_ = ctx.JSON(500, map[string]string{"error": "创建会话失败"})
			return
		}

		// 在 Session 中存入用户信息
		sess.Set("user_id", 1)
		sess.Set("username", username)
		sess.Set("role", "admin")

		_ = ctx.JSON(200, map[string]string{"msg": "登录成功"})
	})

	// Step 3: 注册需要登录才能访问的路由
	h.Get("/profile", func(ctx *web.Context) {
		// 尝试从请求中获取 Session
		sess, err := manager.GetSession(context.Background(), ctx.Req)
		if err != nil {
			_ = ctx.JSON(401, map[string]string{"error": "请先登录"})
			return
		}

		// 从 Session 中读取用户信息
		userID := sess.Get("user_id")
		username := sess.Get("username")

		_ = ctx.JSON(200, map[string]any{
			"user_id":  userID,
			"username": username,
		})
	})

	// Step 4: 注册退出登录路由
	h.Post("/logout", func(ctx *web.Context) {
		err := manager.Logout(context.Background(), ctx.Req)
		if err != nil {
			_ = ctx.JSON(400, map[string]string{"error": "退出失败"})
			return
		}
		_ = ctx.JSON(200, map[string]string{"msg": "已退出登录"})
	})

	// Step 5: 用中间件实现统一登录校验（推荐方式）
	// 这样不需要在每个路由里都写 GetSession
	authMiddleware := func(next web.HandleFunc) web.HandleFunc {
		return func(ctx *web.Context) {
			sess, err := manager.GetSession(context.Background(), ctx.Req)
			if err != nil {
				_ = ctx.JSON(401, map[string]string{"error": "请先登录"})
				return // 不调用 next，中断执行
			}

			// 把用户信息存到 Context，供后续使用
			if ctx.UserValues == nil {
				ctx.UserValues = make(map[string]any)
			}
			ctx.UserValues["user"] = sess

			// 已登录，继续执行
			next(ctx)
		}
	}

	// 把需要保护的路由单独注册（实际应用中可能需要分组路由）
	// 这里简化演示
	_ = authMiddleware

	fmt.Println("Server started on :8081")
	_ = h.Start(":8081")
}

// 防护措施一：Cookie 安全设置
// 在 CookiePropagator.Inject 中设置：
http.SetCookie(w, &http.Cookie{
	Name:     "sessid",
	Value:    sessID,
	HttpOnly: true,                // 禁止 JavaScript 读取 Cookie（防 XSS 攻击）
	Secure:   true,                // 只在 HTTPS 协议下传输 Cookie
	SameSite: http.SameSiteStrictMode, // 严格限制跨站发送（防 CSRF 攻击）
})

// 防护措施二：绑定客户端信息
// 在 session id 中编码一些客户端信息（如 User-Agent、IP 地址等）
// 如果检测到这些信息发生变化，说明 session id 可能被盗用
func GenerateSecureSessionID(r *http.Request) string {
	// 收集客户端信息
	userAgent := r.Header.Get("User-Agent")
	remoteAddr := r.RemoteAddr

	// 生成随机数 + 客户端信息 → 混合 → 编码
	b := make([]byte, 16)
	_, _ = rand.Read(b)
	raw := fmt.Sprintf("%x|%s|%s", b, userAgent, remoteAddr)

	// 用 HMAC 签名（防止篡改）
	// secretKey 是服务端持有的密钥，不对外暴露
	h := hmac.New(sha256.New, []byte("your-secret-key"))
	h.Write([]byte(raw))
	return hex.EncodeToString(h.Sum(nil))
}