import (
    "github.com/MeGaNeKoS/neoma/core"
    "github.com/MeGaNeKoS/neoma/neoma"
)

neoma.Register[InputType, OutputType](api, core.Operation{
    OperationID: "get-item",
    Method:      http.MethodGet,
    Path:        "/items/{id}",
    Summary:     "Get an item",
    Tags:        []string{"Items"},
    Errors:      []int{http.StatusNotFound},
}, func(ctx context.Context, input *InputType) (*OutputType, error) {
    // handler logic
})

neoma.Get[I, O](api, "/items/{id}", handler)
neoma.Post[I, O](api, "/items", handler)
neoma.Put[I, O](api, "/items/{id}", handler)
neoma.Patch[I, O](api, "/items/{id}", handler)
neoma.Delete[I, O](api, "/items/{id}", handler)
neoma.Head[I, O](api, "/items/{id}", handler)

neoma.Get[I, O](api, "/items", handler,
    func(op *core.Operation) {
        op.Tags = []string{"Items"}
        op.Description = "List all items"
    },
)

neoma.Get[I, O](api, "/items", handler, neoma.OperationTags("Items"))

type GetItemInput struct {
    ID int `path:"id" doc:"Item ID"`
}
// Matches: GET /items/{id}

type ListInput struct {
    Page    int    `query:"page" minimum:"1" default:"1" doc:"Page number"`
    PerPage int    `query:"per_page" minimum:"1" maximum:"100" default:"20"`
    Search  string `query:"q" doc:"Search query"`
}

type AuthInput struct {
    Token string `header:"Authorization" required:"true" doc:"Bearer token"`
}

type SessionInput struct {
    SessionID string `cookie:"session_id" doc:"Session cookie"`
}

type CreateItemInput struct {
    Body struct {
        Name  string  `json:"name" minLength:"1" maxLength:"100" doc:"Item name"`
        Price float64 `json:"price" minimum:"0" doc:"Item price"`
    }
}

type CreateItemBody struct {
    Name  string  `json:"name" minLength:"1" doc:"Item name"`
    Price float64 `json:"price" minimum:"0" doc:"Item price"`
}

type CreateItemInput struct {
    Body CreateItemBody
}

type UploadInput struct {
    Body struct {
        Name   string        `form:"name"`
        Avatar core.FormFile `form:"avatar"`
    }
}

type BatchUploadInput struct {
    Body struct {
        Label string           `form:"label"`
        Files []core.FormFile  `form:"files"`
    }
}

type UpdateItemInput struct {
    ID     int  `path:"id" doc:"Item ID"`
    DryRun bool `query:"dry_run" doc:"Simulate the update"`
    Body struct {
        Name string `json:"name" doc:"New name"`
    }
}

type IDPath struct {
    ID int `path:"id" doc:"Item ID"`
}

type GetItemInput struct {
    IDPath
}

type UpdateItemInput struct {
    IDPath
    Body UpdateItemBody
}

type GetItemOutput struct {
    Body struct {
        ID   int    `json:"id" doc:"Item ID"`
        Name string `json:"name" doc:"Item name"`
    }
}

type CreateItemOutput struct {
    Location string `header:"Location" doc:"URL of the created item"`
    Body struct {
        ID int `json:"id"`
    }
}

type CreateOutput struct {
    Status int
    Body   MyBody
}

type StreamOutput struct {
    Body func(ctx core.Context, api core.API)
}

type CreateUserInput struct {
    Body struct {
        Name     string   `json:"name" minLength:"1" maxLength:"255" doc:"Full name" example:"Jane Doe"`
        Email    string   `json:"email" format:"email" doc:"Email address"`
        Age      int      `json:"age" minimum:"0" maximum:"150" doc:"Age in years"`
        Role     string   `json:"role" enum:"admin,user,guest" default:"user" doc:"User role"`
        Tags     []string `json:"tags" maxItems:"10" uniqueItems:"true" doc:"User tags"`
        Password string   `json:"password" minLength:"8" writeOnly:"true" doc:"Password"`
    }
}

// Resolver receives the request context.
type Resolver interface {
    Resolve(ctx Context) []error
}

// ResolverWithPath also receives a path buffer for location-aware errors.
type ResolverWithPath interface {
    Resolve(ctx Context, prefix *PathBuffer) []error
}

type AuthInput struct {
    Token string `header:"Authorization" required:"true"`
    UserID int   // populated by resolver
}

func (a *AuthInput) Resolve(ctx core.Context) []error {
    user, err := validateToken(a.Token)
    if err != nil {
        return []error{errors.ErrorUnauthorized("invalid token")}
    }
    a.UserID = user.ID
    return nil
}