package main

import "github.com/iamdanielyin/mod"

// 定义请求和响应结构
type GetUserRequest struct {
    ID string `json:"id" validate:"required" desc:"用户ID"`
}

type GetUserResponse struct {
    Name  string `json:"name" desc:"用户姓名"`
    Email string `json:"email" desc:"用户邮箱"`
}

func main() {
    app := mod.New()

    // 注册服务（推荐使用蛇形命名法）
    app.Register(mod.Service{
        Name:        "get_user",
        DisplayName: "获取用户信息",
        Description: "根据用户ID获取用户详细信息",
        Handler: mod.MakeHandler(func(ctx *mod.Context, req *GetUserRequest, resp *GetUserResponse) error {
            resp.Name = "张三"
            resp.Email = "[email protected]"
            return nil
        }),
        Group: "用户管理",
    })

    app.Run(":8080")
}

app.Register(mod.Service{
    Name:        "get_user",              // 服务名称（推荐蛇形命名）
    DisplayName: "获取用户信息",            // 显示名称
    Description: "根据用户ID获取详细信息",   // 服务描述
    Handler:     mod.MakeHandler(fn),     // 处理函数
    Group:       "用户管理",               // 服务分组
    Sort:        1,                       // 排序
    SkipAuth:    false,                   // 是否跳过认证
    ReturnRaw:   false,                   // 是否返回原始数据
})

func main() {
    app := mod.New()

    // 推荐的中间件调用顺序
    app.UseEncryption()     // 1. 先处理加解密
    app.UseOptionalJWT()    // 2. 再处理认证

    // 注册服务...
    app.Run(":8080")
}

app.UseJWT()  // 所有请求必须提供有效JWT令牌

app.UseOptionalJWT()  // 验证JWT但允许无令牌访问

app.UseOptionalJWT()  // 全局可选认证

// 完全公开的接口
app.Register(mod.Service{
    Name:     "login",
    SkipAuth: true,  // 跳过所有认证检查
    Handler: mod.MakeHandler(func(ctx *mod.Context, req *LoginRequest, resp *LoginResponse) error {
        // 登录逻辑，无需认证
        return nil
    }),
})

// 需要认证的接口
app.Register(mod.Service{
    Name:     "user_info",
    SkipAuth: true,  // 由Handler内部控制
    Handler: mod.MakeHandler(func(ctx *mod.Context, req *UserInfoRequest, resp *UserInfoResponse) error {
        // 手动检查认证状态
        if !ctx.IsAuthenticated() {
            return mod.Reply(401, "需要身份认证")
        }
        // 已认证用户的处理逻辑
        return nil
    }),
})

// 可选认证的接口（个性化功能）
app.Register(mod.Service{
    Name:     "get_articles",
    SkipAuth: true,
    Handler: mod.MakeHandler(func(ctx *mod.Context, req *ArticlesRequest, resp *ArticlesResponse) error {
        if ctx.IsAuthenticated() {
            // 已登录用户看到个性化内容
            resp.Articles = getPersonalizedArticles(ctx.GetUserID())
        } else {
            // 未登录用户看到通用内容
            resp.Articles = getPublicArticles()
        }
        return nil
    }),
})

app.UseJWT()  // 全局强制认证

// 特殊跳过认证的接口
app.Register(mod.Service{
    Name:     "login",
    SkipAuth: true,  // 必须跳过，否则无法登录
    Handler:  mod.MakeHandler(handleLogin),
})

// 自动认证的接口（默认）
app.Register(mod.Service{
    Name:    "user_info",
    // 不设置SkipAuth，框架自动要求JWT认证
    Handler: mod.MakeHandler(func(ctx *mod.Context, req *UserInfoRequest, resp *UserInfoResponse) error {
        // 执行到这里时用户已通过JWT认证
        userID := ctx.GetUserID()    // 保证有值
        username := ctx.GetUsername() // 保证有值
        return nil
    }),
})

// 检查认证状态
if ctx.IsAuthenticated() {
    // 用户已认证
}

// 获取用户信息
userID := ctx.GetUserID()          // 用户ID
username := ctx.GetUsername()      // 用户名
email := ctx.GetUserEmail()        // 邮箱
role := ctx.GetUserRole()          // 角色

// 获取JWT相关信息
token := ctx.GetJWTToken()         // 原始JWT令牌
claims := ctx.GetJWTClaims()       // JWT声明对象

app.UseEncryption()  // 启用全局加解密中间件

app.UseEncryption()

// 启用加解密的服务
app.Register(mod.Service{
    Name:        "create_user",
    DisplayName: "创建用户",
    Description: "包含敏感信息，需要加密传输",
    Handler: mod.MakeHandler(func(ctx *mod.Context, req *CreateUserRequest, resp *CreateUserResponse) error {
        // 请求数据已自动解密
        // 响应数据将自动加密
        return nil
    }),
    Group: "用户管理",
})

// 白名单服务（跳过加解密）
app.Register(mod.Service{
    Name:        "login",
    DisplayName: "用户登录",
    Description: "公开接口，无需加密",
    Handler: mod.MakeHandler(func(ctx *mod.Context, req *LoginRequest, resp *LoginResponse) error {
        // 普通的JSON请求/响应
        return nil
    }),
    Group: "公开服务",
})

app.Register(mod.Service{
    Name:        "admin_data",
    DisplayName: "管理员数据",
    Handler:     mod.MakeHandler(handleAdminData),
    Permission: &mod.PermissionConfig{
        Rules: []mod.PermissionRule{
            {Field: "user.role", Operator: "eq", Value: "admin"},
        },
        Logic: "AND",
    },
})

// 管理员专用服务
app.Register(mod.Service{
    Name: "admin_users",
    Permission: &mod.PermissionConfig{
        Rules: []mod.PermissionRule{
            {Field: "user.role", Operator: "eq", Value: "admin"},
        },
    },
})

// VIP服务（需要VIP等级2以上）
app.Register(mod.Service{
    Name: "vip_service",
    Permission: &mod.PermissionConfig{
        Rules: []mod.PermissionRule{
            {Field: "user.vip_level", Operator: "gte", Value: 2},
            {Field: "user.status", Operator: "eq", Value: "active"},
        },
        Logic: "AND",
    },
})

// 多角色服务
app.Register(mod.Service{
    Name: "manager_data",
    Permission: &mod.PermissionConfig{
        Rules: []mod.PermissionRule{
            {Field: "user.role", Operator: "in", Value: []string{"admin", "manager"}},
        },
    },
})

tokenData := map[string]interface{}{
    "user": map[string]interface{}{
        "id":        "123",
        "role":      "admin",
        "vip_level": 3,
        "status":    "active",
    },
    "permissions": map[string]interface{}{
        "user_management": true,
        "financial_data":  false,
    },
    "department": map[string]interface{}{
        "name":  "技术部",
        "level": 4,
    },
}

app.SetToken(accessToken, tokenData)

func handler(ctx *mod.Context, req *Request, resp *Response) error {
    // 获取用户信息
    userID := ctx.GetUserID()
    claims := ctx.GetJWTClaims()

    // 检查权限
    if !ctx.HasRole("admin") {
        return mod.Reply(403, "权限不足")
    }

    // 结构化日志
    ctx.WithFields(map[string]interface{}{
        "user_id": userID,
        "action":  "update_user",
    }).Info("用户更新操作")

    // 获取应用实例
    config := ctx.App().GetModConfig()

    return nil
}

func main() {
    app := mod.New()

    // 选择认证模式（推荐可选模式）
    app.UseOptionalJWT()

    // 注册服务...
    app.Run(":8080")
}

// 用户登录 - 生成JWT
app.Register(mod.Service{
    Name:     "login",
    SkipAuth: true,  // 登录接口跳过认证
    Handler: mod.MakeHandler(func(ctx *mod.Context, req *LoginRequest, resp *LoginResponse) error {
        // 验证用户名密码...
        user := validateUser(req.Username, req.Password)

        // 生成JWT令牌
        tokens, err := app.GenerateJWT(
            user.ID,
            user.Username,
            user.Email,
            user.Role,
            map[string]interface{}{  // 自定义声明
                "login_time": time.Now().Unix(),
                "permissions": []string{"read", "write"},
            },
        )
        if err != nil {
            return mod.Reply(500, "生成令牌失败")
        }

        // 可选：存储令牌到缓存用于权限控制
        tokenData := map[string]interface{}{
            "user_id": user.ID,
            "role":    user.Role,
            "status":  "active",
        }
        app.SetToken(tokens.AccessToken, tokenData)

        resp.User = user
        resp.Token = tokens
        return nil
    }),
})

// 需要认证的接口
app.Register(mod.Service{
    Name:     "user_info",
    SkipAuth: true,  // 使用内部认证控制
    Handler: mod.MakeHandler(func(ctx *mod.Context, req *UserInfoRequest, resp *UserInfoResponse) error {
        // 检查是否已认证
        if !ctx.IsAuthenticated() {
            return mod.Reply(401, "需要身份认证")
        }

        // 获取用户信息
        userID := ctx.GetUserID()
        username := ctx.GetUsername()
        role := ctx.GetUserRole()

        resp.User = User{
            ID:       userID,
            Username: username,
            Role:     role,
        }
        return nil
    }),
})

// 令牌刷新
app.Register(mod.Service{
    Name:     "refresh",
    SkipAuth: true,
    Handler: mod.MakeHandler(func(ctx *mod.Context, req *RefreshRequest, resp *mod.TokenResponse) error {
        // 刷新令牌
        tokens, err := app.RefreshJWT(req.RefreshToken)
        if err != nil {
            return mod.Reply(401, "刷新令牌无效")
        }

        *resp = *tokens
        return nil
    }),
})

// 用户登出
app.Register(mod.Service{
    Name:     "logout",
    SkipAuth: true,
    Handler: mod.MakeHandler(func(ctx *mod.Context, req *LogoutRequest, resp *LogoutResponse) error {
        token := ctx.GetJWTToken()
        if token == "" {
            return mod.Reply(401, "未提供令牌")
        }

        // 撤销令牌（加入黑名单）
        if err := app.RevokeJWT(token); err != nil {
            return mod.Reply(500, "登出失败")
        }

        // 从缓存移除令牌
        app.RemoveToken(token)

        resp.Message = "登出成功"
        return nil
    }),
})

// 检查认证状态
if ctx.IsAuthenticated() {
    // 用户已认证
}

// 获取用户信息
userID := ctx.GetUserID()          // 用户ID
username := ctx.GetUsername()      // 用户名
email := ctx.GetUserEmail()        // 邮箱
role := ctx.GetUserRole()          // 角色

// 获取JWT相关信息
token := ctx.GetJWTToken()         // 原始JWT令牌
claims := ctx.GetJWTClaims()       // JWT声明对象

// 获取自定义声明
if claims != nil {
    loginTime := claims.ExtraClaims["login_time"]
}

// 令牌验证失败时的错误响应
{
  "code": 401,
  "message": "Invalid authentication token",
  "data": null,
  "timestamp": "2024-01-01T12:00:00Z"
}

// 启用加解密中间件
app.UseEncryption()

// 手动加解密
encrypted, err := app.EncryptData(data, "symmetric")
decrypted, err := app.DecryptData(encrypted, "symmetric")

// 数字签名
signature, err := app.SignData(data)
err = app.VerifySignature(data, signature)

// 基础日志
ctx.Info("用户登录成功")

// 结构化日志
ctx.WithFields(map[string]interface{}{
    "user_id": "123",
    "action":  "login",
    "ip":      "192.168.1.1",
}).Info("用户登录成功")

// 获取Logger实例
logger := ctx.Logger()
logger.WithField("key", "value").Warn("警告信息")