package main

import (
    "fmt"
    "log"
    "os"

    "github.com/translated/lara-go/lara"
)

func main() {
    // Set your credentials using environment variables (recommended)
    accessKeyID := os.Getenv("LARA_ACCESS_KEY_ID")
    accessKeySecret := os.Getenv("LARA_ACCESS_KEY_SECRET")

    // Create translator instance
    laraTranslator := lara.NewTranslator(lara.NewCredentials(accessKeyID, accessKeySecret), nil)

    // Simple text translation
    result, err := laraTranslator.Translate("Hello, world!", "en-US", "fr-FR", lara.TranslateOptions{})
    if err != nil {
        log.Printf("Translation error: %v", err)
        return
    }

    fmt.Printf("Translation: %s\n", *result.Translation.String)
    // Output: Translation: Bonjour, le monde !
}

credentials := lara.NewCredentials("your-access-key-id", "your-access-key-secret")
laraTranslator := lara.NewTranslator(credentials, nil)

accessKeyID := os.Getenv("LARA_ACCESS_KEY_ID")
accessKeySecret := os.Getenv("LARA_ACCESS_KEY_SECRET")
credentials := lara.NewCredentials(accessKeyID, accessKeySecret)

// Create translator with credentials
laraTranslator := lara.NewTranslator(credentials, nil)

// Basic translation
result, err := laraTranslator.Translate("Hello", "en-US", "fr-FR", lara.TranslateOptions{})

// Multiple strings
result, err := laraTranslator.Translate([]string{"Hello", "World"}, "en-US", "fr-FR", lara.TranslateOptions{})

// TextBlocks (mixed translatable/non-translatable content)
textBlocks := []lara.TextBlock{
    {Text: "Translatable text", Translatable: true},
    {Text: "<br>", Translatable: false},  // Non-translatable HTML
    {Text: "More translatable text", Translatable: true}
}
result, err := laraTranslator.Translate(textBlocks, "en-US", "fr-FR", lara.TranslateOptions{})

// With advanced options
result, err := laraTranslator.Translate("Hello", "en-US", "fr-FR", lara.TranslateOptions{
    Instructions: []string{"Formal tone"},
    AdaptTo:      []string{"mem_1A2b3C4d5E6f7G8h9I0jKl"},  // Replace with actual memory IDs
    Glossaries:   []string{"gls_1A2b3C4d5E6f7G8h9I0jKl"},  // Replace with actual glossary IDs
    Style:        lara.TranslationStyleFluid,
    TimeoutMs:    10000,
})

filePath := "/path/to/your/document.txt"  // Replace with actual file path
filename := "document.txt"
source := "en-US"
target := "fr-FR"
reader, err := laraTranslator.Documents.Translate(&filePath, &filename, &source, target)

// With options
options := &lara.DocumentTranslateOptions{
    DocumentUploadOptions: lara.DocumentUploadOptions{
        AdaptTo:    []string{"mem_1A2b3C4d5E6f7G8h9I0jKl"},  // Replace with actual memory IDs
        Glossaries: []string{"gls_1A2b3C4d5E6f7G8h9I0jKl"},  // Replace with actual glossary IDs
        Style:      lara.TranslationStyleFluid,
    },
}
reader, err := laraTranslator.Documents.TranslateWithOptions(&filePath, &filename, &source, target, options)

//Optional: upload options
uploadOptions := &lara.DocumentUploadOptions{
    AdaptTo:    []string{"mem_1A2b3C4d5E6f7G8h9I0jKl"},  // Replace with actual memory IDs
    Glossaries: []string{"gls_1A2b3C4d5E6f7G8h9I0jKl"}  // Replace with actual glossary IDs
}

document, err := laraTranslator.Documents.UploadWithOptions(&filePath, &filename, &source, target, uploadOptions)

status, err := laraTranslator.Documents.Status(document.ID)

reader, err := laraTranslator.Documents.Download(document.ID)

// Create memory
memory, err := laraTranslator.Memories.Create("MyMemory")

// Create memory with external ID (MyMemory integration)
memory, err := laraTranslator.Memories.CreateWithExternalID("Memory from MyMemory", "aabb1122")  // Replace with actual external ID

// Important: To update/overwrite a translation unit you must provide a tuid. Calls without a tuid always create a new unit and will not update existing entries.
// Add translation to single memory
memoryImport, err := laraTranslator.Memories.AddTranslation("mem_1A2b3C4d5E6f7G8h9I0jKl", "en-US", "fr-FR", "Hello", "Bonjour")

// Add translation to multiple memories
memoryImport, err := laraTranslator.Memories.AddTranslationMultiple([]string{"mem_1A2b3C4d5E6f7G8h9I0jKl", "mem_2XyZ9AbC8dEf7GhI6jKlMn"}, "en-US", "fr-FR", "Hello", "Bonjour")

// Add with context
memoryImport, err := laraTranslator.Memories.AddTranslationWithContext(
    "mem_1A2b3C4d5E6f7G8h9I0jKl", "en-US", "fr-FR", "Hello", "Bonjour", "greeting_003",
    "sentenceBefore", "sentenceAfter"
)

// TMX import from file
tmxFilePath := "/path/to/your/memory.tmx"  // Replace with actual TMX file path
memoryImport, err := laraTranslator.Memories.ImportTmxFromPath("mem_1A2b3C4d5E6f7G8h9I0jKl", tmxFilePath)

// Delete translation
// Important: if you omit tuid, all entries that match the provided fields will be removed
deleteJob, err := laraTranslator.Memories.DeleteTranslation(
        "mem_1A2b3C4d5E6f7G8h9I0jKl", "en-US", "fr-FR", "Hello", "Bonjour"
)

// Wait for import completion
import "time"
maxWaitTime := 300 * time.Second // 5 minutes
completedImport, err := laraTranslator.Memories.WaitForImport(memoryImport, nil, &maxWaitTime)

// Create glossary
glossary, err := laraTranslator.Glossaries.Create("MyGlossary")

// Import CSV from file
csvFilePath := "/path/to/your/glossary.csv"  // Replace with actual CSV file path
glossaryImport, err := laraTranslator.Glossaries.ImportCsvFromPath("gls_1A2b3C4d5E6f7G8h9I0jKl", csvFilePath)

// Check import status
importStatus, err := laraTranslator.Glossaries.GetImportStatus("gls_1A2b3C4d5E6f7G8h9I0jKl")

// Wait for import completion
import "time"
maxWaitTime := 300 * time.Second // 5 minutes
completedImport, err := laraTranslator.Glossaries.WaitForImport(glossaryImport, nil, &maxWaitTime)

// Export glossary
csvData, err := laraTranslator.Glossaries.Export("gls_1A2b3C4d5E6f7G8h9I0jKl", "csv/table-uni", "en-US")

// Get glossary terms count
counts, err := laraTranslator.Glossaries.Counts("gls_1A2b3C4d5E6f7G8h9I0jKl")

type TranslateOptions struct {
    AdaptTo      []string                   // Memory IDs to adapt to
    Glossaries   []string                   // Glossary IDs to use
    Instructions []string                   // Translation instructions
    Style        TranslationStyle           // Translation style (fluid, faithful, creative)
    ContentType  string                     // Content type (text/plain, text/html, etc.)
    Multiline    *bool                      // Enable multiline translation
    TimeoutMs    int                        // Request timeout in milliseconds
    SourceHint   string                     // Hint for source language detection
    NoTrace      *bool                      // Disable request tracing
    Verbose      *bool                      // Enable verbose response
}

// Full language codes (recommended)
result, err := laraTranslator.Translate("Hello", "en-US", "fr-FR", lara.TranslateOptions{})

// Simple language codes
result, err := laraTranslator.Translate("Hello", "en", "fr", lara.TranslateOptions{})

languages, err := laraTranslator.Languages()
fmt.Printf("Supported languages: %v\n", languages)

result, err := laraTranslator.Translate("Hello", "en-US", "fr-FR", lara.TranslateOptions{})
if err != nil {
    if laraErr, ok := err.(*lara.LaraError); ok {
        fmt.Printf("API Error [%d]: %s\n", laraErr.Status, laraErr.Message)
        fmt.Printf("Error type: %s\n", laraErr.Type)
    } else {
        fmt.Printf("SDK Error: %v\n", err)
    }
    return
}