package hello

import (
    "github.com/leochen2038/play"
)

type ProcHelloSay struct {
    Input struct {
        Name string `key:"name" default:"World" note:"姓名"`
    }
    Output struct {
        Message string `key:"message" note:"问候语"`
    }
}

func (p *ProcHelloSay) Run(ctx *play.Context) (string, error) {
    p.Output.Message = "Hello, " + p.Input.Name + "!"
    return "RC_NORMAL", nil
}

package hello

import (
    "hello/library/db"
    "hello/library/metas"

    "github.com/leochen2038/play"
)

type ProcHelloSave struct {
    Input struct {
        Name    string `key:"name"     required:"true"  note:"姓名"`
        Content string `key:"content"  required:"true"  note:"内容" `
    }
    Output struct {
        Id int `key:"id" note:"新记录ID"`
    }
}

func (p *ProcHelloSave) Run(ctx *play.Context) (string, error) {
    msg := metas.NewDHelloTMessage().
        SetFname(p.Input.Name).
        SetFcontent(p.Input.Content)

    if err := db.DHelloTMessage(ctx).Save(msg); err != nil {
        return "", play.WrapErr(err).WrapTip("保存失败")
    }

    p.Output.Id = msg.Fid
    return "RC_NORMAL", nil
}

package hello

import (
    "hello/library/db"

    "github.com/leochen2038/play"
)

type ProcHelloList struct {
    Input struct {
        Name string `key:"name" note:"按姓名筛选(可选)"`
    }
    Output struct {
        List []Message `key:"list" note:"消息列表"`
    }
}

type Message struct {
	Id      int    `key:"id" note:"ID"`
	Name    string `key:"name" note:"姓名"`
	Content string `key:"content" note:"内容"`
}

func (p *ProcHelloList) Run(ctx *play.Context) (string, error) {
    query := db.DHelloTMessage(ctx)

    // 如果传了 name 参数，按姓名筛选
    if p.Input.Name != "" {
        query = query.WhereFnameEqual(p.Input.Name)
    }

    list, err := query.OrderByFidDesc().Limit(0, 20).GetList()
    if err != nil && err != play.ErrQueryEmptyResult {
        return "", play.WrapErr(err).WrapTip("查询失败")
    }

    p.Output.List = make([]Message, len(list))
	for i, msg := range list {
        p.Output.List[i] = Message{
            Id:      msg.Fid,
            Name:    msg.Fname,
            Content: msg.Fcontent,
        }
    }

    return "RC_NORMAL", nil
}

package main

import (
    "fmt"
    "time"
    "hello/hook"

    "github.com/leochen2038/play/config"
    "github.com/leochen2038/play/database"
    "github.com/leochen2038/play/servers"
)

func main() {
    // 加载配置（每 30 秒检测文件变更自动热更新）
    parser, _ := config.NewFileJsonParser("config.json", 30*time.Second)
    config.InitConfig(parser)

    // 注册数据库连接
    mysqlDest, _ := config.String("mysql")
    database.SetDest("mysql", mysqlDest)

    // 创建 HTTP 服务并绑定 Action
    httpInstance := servers.NewHttpInstance("hello", ":8090", hook.NewServerHook(), nil, 5*time.Second)
    httpInstance.BindActionSpace("", "default")

    // 启动
    fmt.Println("Server running at :8090")
    if err := servers.Boot(httpInstance); err != nil {
        fmt.Println(err)
    }
}

package user

import "github.com/leochen2038/play"

type ProcGetUserInfo struct {
    Input struct {
        Uid int `key:"uid" note:"用户ID" required:"true"`
    }
    Output struct {
        Name   string `key:"name" note:"用户名"`
        Avatar string `key:"avatar" note:"头像"`
    }
}

func (p *ProcGetUserInfo) Run(ctx *play.Context) (string, error) {
    // Input 已自动从请求参数绑定 (支持 URL Query / Form / JSON Body)
    uid := p.Input.Uid

    // 业务逻辑...
    p.Output.Name = "张三"
    p.Output.Avatar = "https://example.com/avatar.png"

    // Output 字段会自动序列化到响应 JSON 中
    return "RC_NORMAL", nil
}

package hook

import (
    "time"
    "github.com/leochen2038/play"
    "github.com/leochen2038/play/logger"
)

type ServerHook struct{}

func NewServerHook() play.IServerHook {
    return &ServerHook{}
}

func (h ServerHook) OnBoot(server play.IServer) {
    // 服务启动后回调，可在此自定义 Action 超时
    server.UpdateActionTimeout("", "order.create", 3*time.Second)
}

func (h ServerHook) OnShutdown(server play.IServer) {
    // 服务关闭前回调
}

func (h ServerHook) OnConnect(sess *play.Session, err error) {
    // 连接建立时回调
}

func (h ServerHook) OnClose(sess *play.Session, err error) {
    // 连接关闭时回调
}

func (h ServerHook) OnRequest(ctx *play.Context) error {
    // 请求进入时回调（在 Action 执行前）
    // 可用于鉴权、参数预处理等
    return nil
}

func (h ServerHook) OnResponse(ctx *play.Context) {
    // Action 执行后、响应发送前的回调
    // 通常在此统一包装响应格式
    if ctx.Err() != nil {
        rc, msg := 0x100, ctx.Err().Error()
        if errCode, ok := ctx.Err().(play.Err); ok {
            if errCode.Code() > 0 { rc = errCode.Code() }
            if errCode.Tip() != "" { msg = errCode.Tip() }
        }
        ctx.Response.Output.Set("rc", rc)
        ctx.Response.Output.Set("msg", msg)
    } else {
        ctx.Response.Output.Set("rc", 0)
    }
    ctx.Response.Output.Set("tm", time.Now().Unix())
}

func (h ServerHook) OnFinish(ctx *play.Context) {
    // 请求完全结束后的回调（异步执行）
    logger.Access(ctx)
}

// 查询单条
user, err := db.MydbUserInfo(ctx).WhereFuidEqual(123).GetOne()

// 查询列表
list, err := db.MydbUserInfo(ctx).WhereFstatusEqual(1).GetList()

// 链式条件
list, err := db.MydbUserInfo(ctx).
    WhereFstatusEqual(1).
    WhereFctimeGreater(timestamp).
    GetList()

// HTTP 服务
httpInstance := servers.NewHttpInstance("http", ":8080", hook, nil, timeout)

// H2C (HTTP/2 无 TLS) 服务
h2cInstance := servers.NewH2cInstance("h2c", ":8081", hook, nil, timeout)

// TCP 服务
tcpInstance := servers.NewTcpInstance("tcp", ":9000", hook, nil, timeout)

// WebSocket 服务 (挂载到 HTTP 实例)
wsInstance := servers.NewWsInstance("ws", "", hook, nil, timeout)
wsInstance.BindActionSpace("", "ws_actions")
httpInstance.SetWSInstance(wsInstance)

// SSE 服务 (挂载到 HTTP 实例)
sseInstance := servers.NewSSEInstance("sse", "", hook, nil, timeout)
sseInstance.BindActionSpace("", "sse_actions")
httpInstance.SetSSEInstance(sseInstance)

// TLS 支持
cert, _ := tls.LoadX509KeyPair("cert.pem", "key.pem")
httpInstance.WithCertificate(cert)

// 同时启动多个服务
servers.Boot(httpInstance, h2cInstance, tcpInstance)

mcpInst := servers.NewMCPInstance("myMCP", "", hook, play.MCP_TRANSPORT_STDIO, 5*time.Second)
mcpInst.BindActionSpace("", "default")
servers.Boot(mcpInst)

mcpInst := servers.NewMCPInstance("myMCP", ":8091", hook, play.MCP_TRANSPORT_STREAMABLE_HTTP, 5*time.Second)
mcpInst.BindActionSpace("", "default")
servers.Boot(mcpInst)

httpInst := servers.NewHttpInstance("api", ":8090", hook, nil, 5*time.Second)
httpInst.BindActionSpace("", "default")

mcpInst := servers.NewMCPInstance("mcp", "", hook, play.MCP_TRANSPORT_STREAMABLE_HTTP, 5*time.Second)
mcpInst.BindActionSpace("", "default")
httpInst.SetMCPInstance(mcpInst)

servers.Boot(httpInst)

mcpInst := servers.NewMCPInstance("myMCP", "", hook, play.MCP_TRANSPORT_STDIO, 5*time.Second)
mcpInst.BindActionSpace("", "default")

mcpSrv := mcpInst.MCPServer()
mcpSrv.AddResource(...)
mcpSrv.AddPrompt(...)

servers.Boot(mcpInst)

// 从 JSON 文件初始化（支持热更新）
parser, _ := config.NewFileJsonParser("config.json", 30*time.Second)
config.InitConfig(parser)

// 读取配置
port, _ := config.String("listen.http")    // 支持点号分隔的层级 key
debug, _ := config.Bool("debug")
maxConn, _ := config.Int("pool.maxConn")
rate, _ := config.Float64("rate.limit")

import "github.com/leochen2038/play/logger"

// 设置日志级别
logger.SetLevel(logger.LEVEL_INFO)  // DEBUG=3, INFO=2, WARN=1, ERROR=0

// 设置日志保留天数
logger.SetLogKeepDays(7)

// 在 Processor 中使用
func (p *ProcExample) Run(ctx *play.Context) (string, error) {
    logger.Info(ctx, "处理开始", "uid", uid)
    logger.Debug(ctx, "调试信息", "key", value)
    logger.Warn(ctx, "警告信息")
    logger.Error(ctx, err, "key", value)

    // Access 日志（通常在 OnFinish 钩子中调用）
    logger.Access(ctx)

    return "RC_NORMAL", nil
}

package crontab

type CleanExpiredData struct{}

func (c *CleanExpiredData) Run() {
    // 定时执行的逻辑
}

// 从文件加载 cron 配置
play.CronStartWithFile("cron.json", 30)

// 或代码动态更新
play.CronUpdate([]play.CronConfig{
    {Name: "crontab.CleanExpiredData", Spec: "0 3 * * *"},
})

func (p *ProcExample) Run(ctx *play.Context) (string, error) {
    data, err := queryData()
    if err != nil {
        // 包装错误，自动记录调用栈
        return "", play.WrapErr(err, "uid", uid).
            WrapCode(1001).           // 业务错误码
            WrapTip("查询数据失败")     // 用户可见的提示信息
    }
    return "RC_NORMAL", nil
}

import "github.com/leochen2038/play/agents"

// 设置服务路由
agents.H2cWithForm.SetRouter("user-service", "http://10.0.0.1:8081")

// 发起调用
req := UserInfoReq{Uid: "123"}
sendData, _ := agents.H2cWithForm.Marshal(ctx, "user-service", "user.info", req)
recvData, _ := agents.H2cWithForm.Request(ctx, "user-service", "user.info", sendData)

var resp UserInfoResp
agents.H2cWithForm.Unmarshal(ctx, "user-service", "user.info", recvData, &resp)