package main

import (
    "context"
    "fmt"
    "time"
    "github.com/LingByte/ling-base/common/captcha"
)

func main() {
    // Initialize the global manager with defaults.
    captcha.InitGlobalManager(captcha.DefaultConfig())

    // Generate a random challenge (picks one of the six types).
    result, err := captcha.EnsureGlobalManager().GenerateRandom()
    if err != nil {
        panic(err)
    }
    fmt.Printf("Captcha ID: %s, Type: %s\n", result.ID, result.Type)

    // Verify the user's answer (consumes the captcha on success).
    ok, err := captcha.VerifyPayload(captcha.Payload{
        ID:    result.ID,
        Type:  result.Type,
        Value: /* user's answer */,
    })
    fmt.Println("Valid:", ok, "Error:", err)
}

ic := captcha.NewImageCaptcha(200, 60, 4, 5*time.Minute, nil)
result, _ := ic.Generate()
// result.Data["image"] is a base64 PNG data URL.
// result.Data["length"] is the code length (4).

ok, _ := ic.Verify(result.ID, "ABCD")  // case-insensitive

cc := captcha.NewClickCaptcha(300, 200, 3, 20, 5*time.Minute, nil)
result, _ := cc.Generate()
// result.Data["targets"] is the ordered list of target characters.
// result.Data["chars"] is all character positions (targets + decoys).
// result.Data["background"] is a base64 PNG data URL.
// result.Data["tolerance"] is the click tolerance in pixels.

// User clicks in order; each click is a Point{X, Y}.
ok, _ := cc.Verify(result.ID, []captcha.Point{
    {X: 50, Y: 80},
    {X: 120, Y: 90},
    {X: 200, Y: 75},
})

sc := captcha.NewSliderCaptcha(300, 0.92, 5*time.Minute, nil)
result, _ := sc.Generate()
// result.Data["trackWidth"] is the track width in pixels.

ok, _ := sc.Verify(result.ID, 290)  // must be >= 0.92 * 300 = 276

mc := captcha.NewMathCaptcha(5*time.Minute, nil)
result, _ := mc.Generate()
// result.Data["question"] is e.g. "3 + 5 = ?"

ok, _ := mc.Verify(result.ID, 8)
// or: ok, _ := mc.VerifyString(result.ID, "8")

jc := captcha.NewJigsawCaptcha(300, 150, 40, 5, 5*time.Minute, nil)
result, _ := jc.Generate()
// result.Data["background"] is the background with the cutout masked.
// result.Data["piece"] is the puzzle piece image.
// result.Data["pieceSize"] is the piece size in pixels.
// result.Data["tolerance"] is the X tolerance in pixels.

ok, _ := jc.Verify(result.ID, 180)  // user's drag X position

rc := captcha.NewRotateCaptcha(200, 15, 5*time.Minute, nil)
result, _ := rc.Generate()
// result.Data["image"] is the rotated image as a base64 PNG.
// result.Data["size"] is the image dimensions (square).
// result.Data["tolerance"] is the angular tolerance in degrees.

ok, _ := rc.Verify(result.ID, 90)  // user's rotation angle

cfg := &captcha.Config{
    ImageWidth:       200,
    ImageHeight:      60,
    ImageLength:      4,
    ClickWidth:       300,
    ClickHeight:      200,
    ClickCount:       3,
    ClickTolerance:   30,
    SliderTrackWidth: 300,
    SliderPassRatio:  0.92,
    JigsawWidth:      300,
    JigsawHeight:     150,
    JigsawPieceSize:  40,
    JigsawTolerance:  5,
    RotateSize:       200,
    RotateTolerance:  15,
    Expiration:       5 * time.Minute,
    Store:            captcha.NewMemoryStore(),
}
m := captcha.NewManager(cfg)

type Store interface {
    Set(id string, data interface{}, expires time.Time) error
    Get(id string) (interface{}, error)
    Delete(id string) error
    VerifyWithFunc(id string, input interface{}, compareFunc func(stored, input interface{}) bool) (bool, error)
    VerifyWithFuncWithoutDelete(id string, input interface{}, compareFunc func(stored, input interface{}) bool) (bool, error)
}

// Generate a specific type.
result, err := m.Generate(captcha.TypeImage)

// Generate a random type.
result, err := m.GenerateRandom()

// Verify a payload (consumes on success).
ok, err := m.Verify(captcha.Payload{ID: id, Type: captcha.TypeMath, Value: 42})

// Validate via the global manager (convenience for HTTP handlers).
err := captcha.ValidatePayload(id, typeStr, value)

go test ./... -v
go test ./... -cover