package main

import (
    "context"
    "fmt"
    "log"

    "github.com/carvalab/openbymadata"
)

func main() {
    // Crear cliente (caché de 5 minutos habilitado por defecto)
    client := openbymadata.NewClient()
    ctx := context.Background()

    // Conseguir acción específica de EEUU (CEDEAR)
    aapl, err := client.GetCedear(ctx, "AAPL")
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("🍎 AAPL: $%.2f (%.2f%%)\n", aapl.Last, aapl.Change)

    // Búsqueda universal (recomendada)
    security, err := client.GetSecurity(ctx, "BMA")
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("🔍 BMA: $%.2f\n", security.Last)
}

// Búsqueda universal (funciona para cualquier tipo de valor)
security, err := client.GetSecurity(ctx, "AAPL")

// Tipos específicos
aapl, err := client.GetCedear(ctx, "AAPL")     // CEDEARs (acciones de EEUU)
ggal, err := client.GetBluechip(ctx, "GGAL")  // Acciones líderes argentinas

watchlist := []string{"AAPL", "MSFT", "GOOGL", "GGAL"}
securities, err := client.GetMultipleSecurities(ctx, watchlist)

// Últimos 30 días
historyData, err := client.GetHistoryLastDays(ctx, "SPY", 30)

// Rango personalizado
weeklyData, err := client.GetHistory(ctx, "AAPL", "W", from, to)

// Conseguir todas las acciones líderes (en caché por 5 minutos)
bluechips, err := client.GetBluechips(ctx)
if err != nil {
    log.Fatal(err)
}

fmt.Printf("Encontradas %d acciones líderes:\n", len(bluechips))
for _, security := range bluechips[:5] { // Mostrar las primeras 5
    fmt.Printf("  %s: $%.2f (%.2f%%)\n", 
        security.Symbol, security.Last, security.Change)
}

// Crear cliente con opciones personalizadas
opts := &openbymadata.ClientOptions{
    Timeout:       30 * time.Second,
    RetryAttempts: 5,
    Logger:        customLogger, // Tu implementación de logger
}

client := openbymadata.NewClient(opts)

// Búsqueda universal (recomendada - busca en todos los tipos de valores)
security, err := client.GetSecurity(ctx, "AAPL")    // Funciona para cualquier símbolo

// Tipos específicos de valores
aapl, err := client.GetCedear(ctx, "AAPL")          // Acciones de EEUU (CEDEARs)
ggal, err := client.GetBluechip(ctx, "GGAL")        // Acciones líderes argentinas
galpone, err := client.GetGalpone(ctx, "SYMBOL")    // Panel general
bond, err := client.GetBond(ctx, "AL30")            // Todos los tipos de bonos
option, err := client.GetOption(ctx, "GGAL123")     // Opciones
future, err := client.GetFuture(ctx, "DOE25")       // Futuros

// Conseguir múltiples valores eficientemente (usa caché compartida)
watchlist := []string{"AAPL", "MSFT", "GOOGL", "GGAL"}
securities, err := client.GetMultipleSecurities(ctx, watchlist)

// Buscar valores por símbolo parcial
results, err := client.SearchSecurities(ctx, "APP")  // Encuentra símbolos que contienen "APP"

// Obtener datos históricos para los últimos 30 días (automáticamente agrega "24HS")
historyData, err := client.GetHistoryLastDays(ctx, "SPY", 30)

// Obtener datos históricos con rango de fechas personalizado
// Símbolos se normalizan automáticamente (se agrega "24HS" si no está presente)
// Resolución: "D" = diario, "W" = semanal, "M" = mensual
// from/to son time.Time (conversión a Unix automática)
from := time.Now().AddDate(0, -3, 0)  // 3 meses atrás
to := time.Now()                      // ahora
weeklyData, err := client.GetHistory(ctx, "AAPL", "W", from, to)

// Los datos retornan OHLCV como slices separados (formato más eficiente)
for i := range len(historyData.Time) {
    fmt.Printf("%s: Close=$%.2f, Volume=%d\n", 
        historyData.Time[i].Format("2006-01-02"), historyData.Close[i], historyData.Volume[i])
}

// Opcional: Convertir a formato estructurado si es necesario
structuredData, err := client.ConvertToHistoricalData(historyData)
for _, candle := range structuredData {
    fmt.Printf("%s: Close=$%.2f\n", candle.Time.Format("2006-01-02"), candle.Close)
}

// Chequear si el mercado está operando hoy
isWorking, err := client.IsWorkingDay(ctx)

// Conseguir índices del mercado (Merval, etc.)
indices, err := client.GetIndices(ctx)

// Conseguir resumen del mercado
summary, err := client.MarketResume(ctx)

// Todos los valores de un tipo específico (en caché por 5 minutos)
bluechips, err := client.GetBluechips(ctx)  // → endpoint 'leading-equity'
galpones, err := client.GetGalpones(ctx)    // → endpoint 'general-equity'  
cedears, err := client.GetCedears(ctx)      // → endpoint 'cedears'

// Bonos gubernamentales
bonds, err := client.GetBonds(ctx)

// Letras de corto plazo (LEBACs)
shortTermBonds, err := client.GetShortTermBonds(ctx)

// Bonos corporativos
corporateBonds, err := client.GetCorporateBonds(ctx)

// Contratos de opciones
options, err := client.GetOptions(ctx)

// Contratos de futuros
futures, err := client.GetFutures(ctx)

// Noticias del mercado (en caché por 5 minutos)
news, err := client.GetNews(ctx)

// Estados de resultados para un ticker específico (en caché por símbolo)
statements, err := client.GetIncomeStatement(ctx, "GGAL")

// Conseguir información de caché
cacheInfo := client.GetCacheInfo()
fmt.Printf("Estado del caché: %+v\n", cacheInfo)

// Limpiar todos los datos en caché (fuerza llamadas frescas a la API)
client.ClearCache()

// Deshabilitar caché (no recomendado)
client := openbymadata.NewClient(&openbymadata.ClientOptions{
    EnableCache: false,
})

type Security struct {
    Symbol         string    `json:"symbol"`
    Settlement     string    `json:"settlement"`
    BidSize        int64     `json:"bid_size"`
    Bid            float64   `json:"bid"`
    Ask            float64   `json:"ask"`
    AskSize        int64     `json:"ask_size"`
    Last           float64   `json:"last"`
    Close          float64   `json:"close"`
    Change         float64   `json:"change"`
    Open           float64   `json:"open"`
    High           float64   `json:"high"`
    Low            float64   `json:"low"`
    PreviousClose  float64   `json:"previous_close"`
    Turnover       float64   `json:"turnover"`
    Volume         int64     `json:"volume"`
    Operations     int64     `json:"operations"`
    DateTime       time.Time `json:"datetime"`
    Group          string    `json:"group"`
}

type Bond struct {
    // All Security fields plus:
    Expiration     time.Time `json:"expiration"`
}

type Option struct {
    Symbol          string    `json:"symbol"`
    // ... price fields ...
    UnderlyingAsset string    `json:"underlying_asset"`
    Expiration      time.Time `json:"expiration"`
}

func TestMyBusinessLogic(t *testing.T) {
    // Create test server with mock responses
    server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        mockResponse := []openbymadata.Security{
            {Symbol: "GGAL", Last: 150.50},
        }
        json.NewEncoder(w).Encode(mockResponse)
    }))
    defer server.Close()

    // Create client pointing to test server
    client := openbymadata.NewClient(&openbymadata.ClientOptions{
        BaseURL: server.URL,
    })

    // Test your business logic
    result, err := myBusinessLogic(client)
    assert.NoError(t, err)
    assert.Equal(t, expectedResult, result)
}

securities, err := client.GetBluechips(ctx)
if err != nil {
    if bymaErr, ok := err.(*openbymadata.BYMAError); ok {
        switch bymaErr.Code {
        case "TIMEOUT":
            // Handle timeout
        case "RATE_LIMITED":
            // Handle rate limiting
        case "API_UNAVAILABLE":
            // Handle API unavailability
        default:
            log.Printf("API error: %v", bymaErr)
        }
    } else {
        log.Printf("Unexpected error: %v", err)
    }
}

// First call - fetches from API (slow)
start := time.Now()
aapl, _ := client.GetCedear(ctx, "AAPL")
fmt.Printf("First call: %v\n", time.Since(start)) // ~100ms

// Second call - returns from cache (fast!)
start = time.Now()
aapl, _ = client.GetCedear(ctx, "AAPL")
fmt.Printf("Cached call: %v\n", time.Since(start)) // ~50µs (100x faster!)

// Multiple securities use shared cache efficiently
securities, _ := client.GetMultipleSecurities(ctx, []string{"AAPL", "MSFT", "GOOGL"})
// All symbols returned instantly from cache!

// Example: Fetch multiple data types concurrently
var wg sync.WaitGroup
var bluechips []Security
var bonds []Bond
var indices []Index

wg.Add(3)

go func() {
    defer wg.Done()
    bluechips, _ = client.GetBluechips(ctx)    // Cached after first call
}()

go func() {
    defer wg.Done()
    bonds, _ = client.GetBonds(ctx)           // Cached after first call
}()

go func() {
    defer wg.Done()
    indices, _ = client.GetIndices(ctx)       // Cached after first call
}()

wg.Wait()