package main

import (
    "context"
    "fmt"
    "log"

    kie "github.com/lpg-it/kie-go"
)

func main() {
    client := kie.NewClient("your-api-key")
    defer client.Close()

    ctx := context.Background()

    // Method 1: Using RequestBuilder with constants (Recommended)
    result, err := kie.Image.NanoBananaPro.Request().
        Prompt("A futuristic city at sunset").
        AspectRatio(kie.Ratio16x9).      // Use predefined constant
        Set(kie.ParamResolution, kie.Resolution4K).
        Generate(ctx, client)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Generated:", result.URLs)

    // Method 2: Using Generate function with constants
    result, err = kie.Generate(ctx, client, kie.NanoBananaPro, kie.Params{
        kie.ParamPrompt:      "A beautiful sunset",
        kie.ParamAspectRatio: kie.Ratio16x9,
        kie.ParamResolution:  kie.Resolution4K,
    })
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Generated:", result.URLs)
}

func NewClient(apiKey string, opts ...Option) *Client

// Basic usage
client := kie.NewClient("your-api-key")

// With options
client := kie.NewClient("your-api-key",
    kie.WithTimeout(60*time.Second),
    kie.WithMaxRetries(5),
    kie.WithRateLimit(10),
)

func (c *Client) CreateTask(ctx context.Context, req *CreateTaskRequest) (*CreateTaskResponse, error)

task, err := client.CreateTask(ctx, &kie.CreateTaskRequest{
    Model: "nano-banana-pro",
    Input: kie.Params{
        "prompt":       "A beautiful sunset",
        "aspect_ratio": "16:9",
    },
    CallbackURL: "https://your-server.com/webhook", // Optional
})
if err != nil {
    log.Fatal(err)
}
fmt.Println("Task ID:", task.TaskID)

func (c *Client) GetTaskStatus(ctx context.Context, taskID string) (*TaskInfo, error)
func (c *Client) WaitForTask(ctx context.Context, taskID string, opts ...WaitOption) (*TaskInfo, error)

// Non-blocking status check
status, err := client.GetTaskStatus(ctx, taskID)

// Blocking wait with exponential backoff
info, err := client.WaitForTask(ctx, taskID,
    kie.WithWaitTimeout(5*time.Minute),
    kie.WithPollInterval(time.Second),
    kie.WithMaxPollInterval(10*time.Second),
)
if err != nil {
    log.Fatal(err)
}

urls, _ := info.GetResultURLs()
fmt.Println("Results:", urls)

// Track progress during long waits
info, err := client.WaitForTask(ctx, taskID,
    kie.WithProgressCallback(func(taskID string, elapsed time.Duration, pollCount int) {
        log.Printf("Task %s: waiting %.1fs (poll #%d)", taskID, elapsed.Seconds(), pollCount)
    }),
)

func DefaultWaitConfig() *WaitConfig
// Returns: Timeout=10min, PollInterval=500ms, MaxPollInterval=5s, PollMultiplier=1.5

func (c *Client) CreateTasksBatch(ctx context.Context, requests []*CreateTaskRequest, opts ...BatchOption) <-chan BatchResult
func (c *Client) WaitForTasksBatch(ctx context.Context, taskIDs []string, opts ...BatchOption) <-chan BatchResult

// Create multiple tasks concurrently
requests := []*kie.CreateTaskRequest{
    {Model: "nano-banana-pro", Input: kie.Params{"prompt": "Cat"}},
    {Model: "nano-banana-pro", Input: kie.Params{"prompt": "Dog"}},
    {Model: "nano-banana-pro", Input: kie.Params{"prompt": "Bird"}},
}

for result := range client.CreateTasksBatch(ctx, requests, kie.WithConcurrency(5)) {
    if result.Error != nil {
        log.Printf("Task %d failed: %v", result.Index, result.Error)
        continue
    }
    log.Printf("Created task %d: %s", result.Index, result.TaskID)
}

// Wait for multiple tasks concurrently
taskIDs := []string{"task1", "task2", "task3"}
for result := range client.WaitForTasksBatch(ctx, taskIDs, kie.WithConcurrency(3)) {
    if result.Error != nil {
        log.Printf("Task %s failed: %v", result.TaskID, result.Error)
        continue
    }
    urls, _ := result.Info.GetResultURLs()
    log.Printf("Task %s completed: %v", result.TaskID, urls)
}

func DefaultBatchConfig() *BatchConfig
// Returns: Concurrency=5, Timeout=10min, PollInterval=500ms, MaxPollInterval=5s

processor := kie.NewBatchProcessor(client,
    kie.WithConcurrency(10),
    kie.WithBatchTimeout(15*time.Minute),
)

// Create and wait for all tasks
results, err := processor.CreateAndWait(ctx, requests)
for _, r := range results {
    if r.Error != nil {
        log.Printf("Task %d failed: %v", r.Index, r.Error)
    } else {
        log.Printf("Task %d completed: %s", r.Index, r.Info.TaskID)
    }
}

// Process RequestBuilders directly
builders := []*model.RequestBuilder{
    kie.NanoBananaPro.Request().Prompt("A sunset"),
    kie.NanoBananaPro.Request().Prompt("A sunrise"),
}
results, err := processor.ProcessBuilders(ctx, builders)

// With progress callback
results, err := processor.ProcessAll(ctx, requests, func(completed, total int) {
    log.Printf("Progress: %d/%d", completed, total)
})

// Build and execute a request with constants (recommended)
result, err := kie.Image.GoogleImagen4.Request().
    Prompt("A futuristic cityscape").
    NegativePrompt("blurry, dark").
    AspectRatio(kie.Ratio16x9).          // Use constant
    Set(kie.ParamSeed, 12345).
    Generate(ctx, client)

if err != nil {
    log.Fatal(err)
}
fmt.Println("URLs:", result.URLs)
fmt.Println("Cost Time:", result.CostTime)

func Generate(ctx context.Context, client *Client, m *Model, params Params, opts ...GenerateOption) (*Result, error)

result, err := kie.Generate(ctx, client, kie.NanoBananaPro, kie.Params{
    kie.ParamPrompt:      "A beautiful sunset",
    kie.ParamAspectRatio: kie.Ratio16x9,
    kie.ParamResolution:  kie.Resolution4K,
},
    kie.WithGenTimeout(5*time.Minute),
    kie.WithGenCallback("https://your-server.com/webhook"),
)

result, err := kie.IdeogramV3Remix.Request().
    Prompt("A futuristic city").
    ImageURL("https://example.com/input.jpg").
    Strength(0.8).
    Style(kie.StyleRealistic).           // Use constant
    ImageSize(kie.SizeSquareHD).         // Use constant
    NumImages("2").
    Generate(ctx, client)

// Get model field information
model := kie.NanoBananaPro

// List required fields
fmt.Println("Required fields:")
for _, f := range model.RequiredFields() {
    fmt.Printf("  - %s (%s): %s\n", f.Name, f.Type, f.Description)
}

// List optional fields
fmt.Println("Optional fields:")
for _, f := range model.OptionalFields() {
    fmt.Printf("  - %s (%s): %s\n", f.Name, f.Type, f.Description)
    if len(f.EnumVals) > 0 {
        fmt.Printf("    Allowed values: %v\n", f.EnumVals)
    }
    if f.Default != nil {
        fmt.Printf("    Default: %v\n", f.Default)
    }
}

const (
    Ratio1x1   = "1:1"
    Ratio16x9  = "16:9"
    Ratio9x16  = "9:16"
    Ratio4x3   = "4:3"
    Ratio3x4   = "3:4"
    Ratio3x2   = "3:2"
    Ratio2x3   = "2:3"
    Ratio5x4   = "5:4"
    Ratio4x5   = "4:5"
    Ratio21x9  = "21:9"
    Ratio9x21  = "9:21"
    RatioAuto  = "auto"
)

const (
    Resolution1K = "1K"
    Resolution2K = "2K"
    Resolution4K = "4K"
)

const (
    FormatPNG  = "png"
    FormatJPG  = "jpg"
    FormatJPEG = "jpeg"
)

const (
    Duration4s  = "4s"
    Duration5s  = "5s"
    Duration8s  = "8s"
    Duration10s = "10s"
)

const (
    Duration4Sec  = "4"
    Duration5Sec  = "5"
    Duration6Sec  = "6"
    Duration8Sec  = "8"
    Duration10Sec = "10"
    Duration12Sec = "12"
    Duration15Sec = "15"
    Duration25Sec = "25"
)

const (
    VideoResolution480p  = "480p"
    VideoResolution580p  = "580p"
    VideoResolution720p  = "720p"
    VideoResolution1080p = "1080p"
    VideoResolution512P  = "512P"
    VideoResolution768P  = "768P"
    VideoResolution1080P = "1080P"
)

const (
    QualityBasic  = "basic"
    QualityMedium = "medium"
    QualityHigh   = "high"
)

const (
    // Common parameters
    ParamPrompt         = "prompt"
    ParamNegativePrompt = "negative_prompt"
    ParamAspectRatio    = "aspect_ratio"
    ParamImageSize      = "image_size"
    ParamResolution     = "resolution"
    ParamOutputFormat   = "output_format"
    ParamSeed           = "seed"

    // Image input parameters
    ParamImage      = "image"
    ParamImageURL   = "image_url"
    ParamImageURLs  = "image_urls"
    ParamImageInput = "image_input"
    ParamInputURLs  = "input_urls"

    // Video parameters
    ParamDuration   = "duration"
    ParamMode       = "mode"
    ParamVideoURL   = "video_url"
    ParamVideoURLs  = "video_urls"
    ParamAudioURL   = "audio_url"

    // Count and scale parameters
    ParamN     = "n"
    ParamScale = "scale"

    // Quality and style parameters
    ParamQuality        = "quality"
    ParamStyle          = "style"
    ParamRenderingSpeed = "rendering_speed"
    ParamNumImages      = "num_images"

    // Advanced parameters
    ParamCfgScale            = "cfg_scale"
    ParamGuidanceScale       = "guidance_scale"
    ParamStrength            = "strength"
    ParamEndImageURL         = "end_image_url"
    ParamTailImageURL        = "tail_image_url"
    ParamPromptOptimizer     = "prompt_optimizer"
    ParamCameraFixed         = "camera_fixed"
    ParamEnableSafetyChecker = "enable_safety_checker"
)

// Using constants for type safety
result, err := kie.NanoBananaPro.Request().
    Prompt("A beautiful sunset").
    Set(kie.ParamAspectRatio, kie.Ratio16x9).
    Set(kie.ParamResolution, kie.Resolution4K).
    Set(kie.ParamOutputFormat, kie.FormatPNG).
    Generate(ctx, client)

// Or with Params
result, err := kie.Generate(ctx, client, kie.NanoBananaPro, kie.Params{
    kie.ParamPrompt:       "A beautiful sunset",
    kie.ParamAspectRatio:  kie.Ratio16x9,
    kie.ParamResolution:   kie.Resolution4K,
})

// Via namespace with constants (recommended)
result, _ := kie.Image.GoogleImagen4.Request().
    Prompt("A beautiful sunset").
    AspectRatio(kie.Ratio16x9).
    Generate(ctx, client)

// Direct access
result, _ := kie.GoogleImagen4.Request().
    Prompt("A beautiful sunset").
    AspectRatio(kie.Ratio16x9).
    Generate(ctx, client)

result, _ := kie.Video.Seedance15Pro.Request().
    Prompt("A dancing robot").
    Duration(kie.Duration10s).           // Use constant
    AspectRatio(kie.Ratio16x9).          // Use constant
    Generate(ctx, client)

// Get model dynamically
model := kie.GetModel("nano-banana-pro")
if model != nil {
    result, _ := model.Request().Prompt("Hello").Generate(ctx, client)
}

// List all models
for _, m := range kie.AllModels() {
    fmt.Printf("Model: %s (%s)\n", m.Name, m.Identifier)
}

uploader := client.FileUploader()

// Upload local file
result, err := uploader.UploadFile(ctx, "/path/to/image.jpg", &kie.UploadOptions{
    UploadPath: "images",
    FileName:   "my-photo.jpg",
})

// Upload from URL
result, err := uploader.UploadFromURL(ctx, "https://example.com/image.jpg", nil)

// Upload base64
result, err := uploader.UploadBase64(ctx, "data:image/png;base64,iVBORw0K...", nil)

// Upload bytes
result, err := uploader.UploadBytes(ctx, imageBytes, "image/jpeg", nil)

uploader := client.FileUploader()

// Step 1: Upload local image
uploadResult, err := uploader.UploadFile(ctx, "./my-photo.jpg", nil)
if err != nil {
    log.Fatal(err)
}
fmt.Printf("Uploaded: %s (expires: %s)\n", uploadResult.FileURL, uploadResult.ExpiresAt)

// Step 2: Use uploaded URL for image-to-video
videoResult, err := kie.Seedance15ImageToVideo.Request().
    Prompt("Make the character wave hello").
    ImageURLs(uploadResult.FileURL).  // Use the uploaded file URL
    Duration("5s").
    Generate(ctx, client)

// Step 3: For video-to-video, upload a video file
videoUpload, err := uploader.UploadFile(ctx, "./input.mp4", nil)
if err != nil {
    log.Fatal(err)
}

transformResult, err := kie.Wan26VideoToVideo.Request().
    Prompt("Transform into anime style").
    Set(kie.ParamVideoURLs, []string{videoUpload.FileURL}).
    Generate(ctx, client)

// Step 4: For avatar with audio, upload both image and audio
audioUpload, err := uploader.UploadFile(ctx, "./speech.mp3", nil)
avatarResult, err := kie.KlingV1AvatarStandard.Request().
    Set(kie.ParamImageURL, uploadResult.FileURL).
    Set(kie.ParamAudioURL, audioUpload.FileURL).
    Prompt("Professional speaking").
    Generate(ctx, client)

func (c *Client) GetDownloadURL(ctx context.Context, fileURL string) (string, error)
func (c *Client) GetDownloadURLs(ctx context.Context, fileURLs []string) ([]string, error)

// Single file
downloadURL, err := client.GetDownloadURL(ctx, "https://tempfile.1f6c...")

// Multiple files (concurrent)
downloadURLs, err := client.GetDownloadURLs(ctx, []string{
    "https://tempfile.1f6c...",
    "https://tempfile.2f7d...",
})

func NewDownloader(opts ...DownloaderOption) *Downloader

// Create downloader with KIE client for auto URL conversion
downloader := kie.NewDownloader(
    kie.WithKIEClient(client),
    kie.WithDownloadConcurrency(10),
)

// Download from task info
results, err := downloader.DownloadFromTaskInfo(ctx, taskInfo, "./output/")
for _, r := range results {
    if r.Error != nil {
        log.Printf("Failed: %v", r.Error)
    } else {
        log.Printf("Downloaded: %s (%d bytes)", r.LocalPath, r.Size)
    }
}

// Download single file
err := downloader.DownloadSingle(ctx, url, "./output/image.png")

// Get current balance
credits, err := client.GetCredits(ctx)
fmt.Printf("Credits: %d\n", credits)

// Check if above threshold
ok, balance, err := client.CheckCredits(ctx, 100)
if !ok {
    log.Printf("Low credits: %d (need 100)", balance)
}

// Simple boolean check
if ok, _ := client.HasSufficientCredits(ctx, 50); !ok {
    log.Fatal("Insufficient credits")
}

func NewWebhookHandler(secretKey string) *WebhookHandler

handler := kie.NewWebhookHandler("your-secret-key")

// Simple handler
http.HandleFunc("/webhook", handler.Handler(func(info *kie.TaskInfo) {
    log.Printf("Task %s completed: %s", info.TaskID, info.State)
    urls, _ := info.GetResultURLs()
    // Process results...
}))

// Handler with error support (returns 500 to trigger retry)
http.HandleFunc("/webhook", handler.HandlerWithError(func(info *kie.TaskInfo) error {
    if err := processTask(info); err != nil {
        return err // Will return 500, KIE will retry
    }
    return nil
}))

// Manual parsing
http.HandleFunc("/webhook", func(w http.ResponseWriter, r *http.Request) {
    info, err := handler.ParseRequest(r)
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }
    // Process info...
    w.WriteHeader(http.StatusOK)
})

func DefaultCircuitBreakerConfig() *CircuitBreakerConfig
func NewCircuitBreaker(config *CircuitBreakerConfig) *CircuitBreaker

type CircuitBreakerConfig struct {
    FailureThreshold int           // Failures before opening (default: 5)
    SuccessThreshold int           // Successes to close (default: 2)
    Timeout          time.Duration // Wait before testing recovery (default: 30s)
}

// Enable via client option
client := kie.NewClient("api-key",
    kie.WithCircuitBreaker(&kie.CircuitBreakerConfig{
        FailureThreshold: 5,
        SuccessThreshold: 2,
        Timeout:          30 * time.Second,
    }),
)

// Manual usage
cb := kie.NewCircuitBreaker(kie.DefaultCircuitBreakerConfig())
if cb.Allow() {
    err := doRequest()
    if err != nil {
        cb.RecordFailure()
    } else {
        cb.RecordSuccess()
    }
}

client := kie.NewClient("api-key",
    kie.WithRateLimit(10), // 10 requests per second
)

type Metrics interface {
    IncCounter(name string, labels ...string)
    ObserveHistogram(name string, value float64, labels ...string)
}

type Tracer interface {
    Start(ctx context.Context, name string) (context.Context, Span)
}

type Span interface {
    SetAttribute(key string, value interface{})
    RecordError(err error)
    End()
}

client := kie.NewClient("api-key",
    kie.WithMetrics(myMetricsCollector),
    kie.WithTracer(myTracer),
)

type APIError struct {
    HTTPStatus int
    Code       int
    Message    string
    RequestID  string
    RetryAfter time.Duration
}

type TaskFailedError struct {
    TaskID   string
    FailCode string
    FailMsg  string
}

result, err := client.WaitForTask(ctx, taskID)
if err != nil {
    switch {
    case errors.Is(err, kie.ErrCircuitOpen):
        log.Fatal("Service unavailable, circuit breaker open")
    case kie.IsAuthError(err):
        log.Fatal("Invalid API key")
    case kie.IsRateLimitError(err):
        log.Println("Rate limited, will retry...")
    case kie.IsInsufficientFundError(err):
        log.Fatal("Please top up your account")
    case errors.Is(err, kie.ErrTaskFailed):
        var taskErr *kie.TaskFailedError
        errors.As(err, &taskErr)
        log.Printf("Task failed: %s - %s", taskErr.FailCode, taskErr.FailMsg)
    default:
        log.Printf("Unknown error: %v", err)
    }
}

const Version = "0.1.0"

const DefaultBaseURL = "https://api.kie.ai"
const DefaultTimeout = 30 * time.Second

const (
    TaskStateWaiting TaskState = "waiting"
    TaskStateSuccess TaskState = "success"
    TaskStateFail    TaskState = "fail"
)

const (
    CircuitClosed   CircuitState = iota
    CircuitOpen
    CircuitHalfOpen
)

const (
    ErrCodeSuccess          = 200
    ErrCodeBadRequest       = 400
    ErrCodeUnauthorized     = 401
    ErrCodeInsufficientFund = 402
    ErrCodeNotFound         = 404
    ErrCodeValidation       = 422
    ErrCodeRateLimit        = 429
    ErrCodeInternal         = 500
)

const (
    CategoryTextToImage  = model.CategoryTextToImage
    CategoryImageToImage = model.CategoryImageToImage
    CategoryImageEdit    = model.CategoryImageEdit
    CategoryUpscale      = model.CategoryUpscale
    CategoryTextToVideo  = model.CategoryTextToVideo
    CategoryImageToVideo = model.CategoryImageToVideo
    CategoryVideoToVideo = model.CategoryVideoToVideo
)