package main

import (
    "context"
    "fmt"
    "log"

    "github.com/easyagent-dev/llm"
    "github.com/easyagent-dev/llm/types"
    "github.com/easyagent-dev/llm/types/completion"
)

func main() {
    // Initialize OpenAI client
    model, err := llm.NewOpenAIModel(
        types.WithAPIKey("your-openai-api-key"),
    )
    if err != nil {
        log.Fatal(err)
    }

    // Create a request
    req := &completion.CompletionRequest{
        Model:        "gpt-4o-mini",
        Instructions: "You are a helpful assistant.",
        Messages: []*types.ModelMessage{
            {
                Role:    types.MessageRoleUser,
                Content: "What is the capital of France?",
            },
        },
        Options: []completion.CompletionOption{
            completion.WithCost(true),
        },
    }

    // Generate response
    resp, err := model.Complete(context.Background(), req, nil)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println("Response:", resp.Output)
    if resp.Cost != nil {
        fmt.Printf("Cost: $%.6f\n", *resp.Cost)
    }
}

func streamExample() {
    model, _ := llm.NewOpenAIModel(
        types.WithAPIKey("your-api-key"),
    )

    req := &completion.CompletionRequest{
        Model:        "gpt-4o-mini",
        Instructions: "You are a helpful assistant.",
        Messages: []*types.ModelMessage{
            {
                Role:    types.MessageRoleUser,
                Content: "Write a short story about AI",
            },
        },
    }

    stream, err := model.StreamComplete(context.Background(), req, nil)
    if err != nil {
        log.Fatal(err)
    }

    for chunk := range stream {
        switch c := chunk.(type) {
        case types.StreamTextChunk:
            fmt.Print(c.Text)
        case types.StreamUsageChunk:
            fmt.Printf("\nTokens used: %d\n", c.Usage.TotalInputTokens+c.Usage.TotalOutputTokens)
        }
    }
}

func multiProviderExample() {
    // Initialize multiple providers
    openai, _ := llm.NewOpenAIModel(
        types.WithAPIKey("openai-key"),
    )

    deepseek, _ := llm.NewDeepSeekModel(
        types.WithAPIKey("deepseek-key"),
    )

    req := &completion.CompletionRequest{
        Model:        "gpt-4o-mini", // or "deepseek-chat", etc.
        Instructions: "You are a helpful assistant.",
        Messages: []*types.ModelMessage{
            {
                Role:    types.MessageRoleUser,
                Content: "Explain quantum computing",
            },
        },
    }

    // Use OpenAI
    resp1, _ := openai.Complete(context.Background(), req, nil)
    fmt.Printf("OpenAI Response: %s\n\n", resp1.Output)

    // Use DeepSeek with same request structure
    req.Model = "deepseek-chat"
    resp2, _ := deepseek.Complete(context.Background(), req, nil)
    fmt.Printf("DeepSeek Response: %s\n\n", resp2.Output)
}

func reasoningExample() {
    // Use reasoning model with completion API
    model, _ := llm.NewOpenAIModel(
        types.WithAPIKey("your-api-key"),
    )

    req := &completion.CompletionRequest{
        Model:        "o4-mini",
        Instructions: "You are a helpful assistant.",
        Messages: []*types.ModelMessage{
            {
                Role:    types.MessageRoleUser,
                Content: "Solve this logic puzzle: If all A are B, and all B are C, what can we conclude?",
            },
        },
        Options: []completion.CompletionOption{
            completion.WithReasoningEffort(completion.ReasoningEffortLow),
        },
    }

    resp, _ := model.Complete(context.Background(), req, nil)
    fmt.Printf("Response: %s\n", resp.Output)
    
    // Access reasoning tokens if available
    if resp.Usage != nil {
        fmt.Printf("Reasoning tokens: %d\n", resp.Usage.TotalReasoningTokens)
    }
}

func conversationExample() {
    // Use conversation API for advanced reasoning
    model, _ := llm.NewOpenAIConversationModel(
        types.WithAPIKey("your-api-key"),
    )

    req := &conversation.ConversationRequest{
        Model: "o4-mini",
        Input: "Explain the theory of relativity in simple terms.",
        Options: []conversation.ResponseOption{
            conversation.WithReasoningEffort(conversation.ReasoningEffortMedium),
            conversation.WithReasoningSummary("detailed"),
        },
    }

    stream, err := model.StreamResponse(context.Background(), req, nil)
    if err != nil {
        log.Fatal(err)
    }

    for chunk := range stream {
        switch c := chunk.(type) {
        case types.StreamTextChunk:
            fmt.Print(c.Text)
        }
    }
    fmt.Println()
}

// OpenAI with custom base URL
openai, _ := llm.NewOpenAIModel(
    types.WithAPIKey("key"),
    types.WithBaseURL("https://api.openai.com/v1"), // Optional
)

// DeepSeek
deepseek, _ := llm.NewDeepSeekModel(
    types.WithAPIKey("key"),
)

// Using environment variables
model, _ := llm.NewOpenAIModel(
    types.WithAPIKey(os.Getenv("OPENAI_API_KEY")),
)

resp, err := client.GenerateContent(ctx, req)
if err != nil {
    // Handle different error types
    switch {
    case strings.Contains(err.Error(), "rate limit"):
        // Handle rate limiting
        time.Sleep(time.Minute)
        return retry()
    case strings.Contains(err.Error(), "insufficient_quota"):
        // Handle quota exceeded
        return handleQuotaError()
    default:
        // Handle other errors
        log.Printf("API Error: %v", err)
    }
}

// Enable cost tracking with options
req := &completion.CompletionRequest{
    Model:        "gpt-4o-mini",
    Instructions: "You are a helpful assistant.",
    Messages: []*types.ModelMessage{
        {
            Role:    types.MessageRoleUser,
            Content: "Hello!",
        },
    },
    Options: []completion.CompletionOption{
        completion.WithCost(true),
        completion.WithUsage(true),
    },
}

resp, _ := model.Complete(ctx, req, nil)

// Access cost information
if resp.Cost != nil {
    fmt.Printf("Request cost: $%.6f\n", *resp.Cost)
}

// Access detailed usage
if resp.Usage != nil {
    fmt.Printf("Input tokens: %d\n", resp.Usage.TotalInputTokens)
    fmt.Printf("Output tokens: %d\n", resp.Usage.TotalOutputTokens)
    fmt.Printf("Reasoning tokens: %d\n", resp.Usage.TotalReasoningTokens)
}