package main

import (
    "database/sql"
    "log"
    "os"
    "sync"
    "time"

    _ "github.com/lib/pq"
)

var (
    db   *sql.DB
    once sync.Once
)

// Input struct for creating a user
type CreateUserRequest struct {
    Email string `json:"email"`
    Name  string `json:"name"`
    Age   int    `json:"age,omitempty"`
}

// Output struct for user data
type User struct {
    ID        int       `json:"id"`
    Email     string    `json:"email"`
    Name      string    `json:"name"`
    Age       int       `json:"age"`
    CreatedAt time.Time `json:"created_at"`
}

// Output struct for user list
type UserListResponse struct {
    Users []User `json:"users"`
    Total int    `json:"total"`
}

func initDB() {
    var err error
    // DATABASE_URL automatically injected by Chita Cloud
    db, err = sql.Open("postgres", os.Getenv("DATABASE_URL"))
    if err != nil {
        log.Fatal("Failed to connect to database:", err)
    }
    
    db.SetMaxOpenConns(10)
    db.SetMaxIdleConns(5)
    db.SetConnMaxLifetime(time.Hour)
}

// Handler to get all users
func GetUsers(req struct{}) (UserListResponse, error) {
    once.Do(initDB)
    
    rows, err := db.Query("SELECT id, email, name, age, created_at FROM users ORDER BY created_at DESC")
    if err != nil {
        return UserListResponse{}, err
    }
    defer rows.Close()
    
    var users []User
    for rows.Next() {
        var user User
        err := rows.Scan(&user.ID, &user.Email, &user.Name, &user.Age, &user.CreatedAt)
        if err != nil {
            continue
        }
        users = append(users, user)
    }
    
    return UserListResponse{
        Users: users,
        Total: len(users),
    }, nil
}

// Handler to create a user
func CreateUser(req CreateUserRequest) (User, error) {
    once.Do(initDB)
    
    var user User
    err := db.QueryRow(
        "INSERT INTO users (email, name, age, created_at) VALUES ($1, $2, $3, $4) RETURNING id, email, name, age, created_at",
        req.Email, req.Name, req.Age, time.Now(),
    ).Scan(&user.ID, &user.Email, &user.Name, &user.Age, &user.CreatedAt)
    
    if err != nil {
        return User{}, err
    }
    
    return user, nil
}

package main

import (
    "fmt"
    "strings"
    "time"
)

// Input struct for creating a product
type CreateProductRequest struct {
    Name        string  `json:"name"`
    Description string  `json:"description"`
    Price       float64 `json:"price"`
    Category    string  `json:"category"`
}

// Input struct for getting products
type GetProductsRequest struct {
    Category string `json:"category,omitempty"`
    Limit    int    `json:"limit,omitempty"`
}

// Output struct for a product
type Product struct {
    ID          int     `json:"id"`
    Name        string  `json:"name"`
    Description string  `json:"description"`
    Price       float64 `json:"price"`
    Category    string  `json:"category"`
    CreatedAt   string  `json:"created_at"`
}

// Output struct for API responses
type APIResponse struct {
    Success   bool        `json:"success"`
    Message   string      `json:"message"`
    Data      interface{} `json:"data,omitempty"`
    Error     string      `json:"error,omitempty"`
    Timestamp string      `json:"timestamp"`
}

// Validation function
func validateProduct(req CreateProductRequest) error {
    if strings.TrimSpace(req.Name) == "" {
        return fmt.Errorf("name is required")
    }
    if len(req.Name) < 3 || len(req.Name) > 100 {
        return fmt.Errorf("name must be between 3 and 100 characters")
    }
    if req.Price <= 0 {
        return fmt.Errorf("price must be greater than 0")
    }
    validCategories := map[string]bool{
        "electronics": true, "books": true, "clothing": true, "home": true,
    }
    if !validCategories[req.Category] {
        return fmt.Errorf("invalid category")
    }
    return nil
}

// Handler to create a product
func CreateProduct(req CreateProductRequest) (APIResponse, error) {
    if err := validateProduct(req); err != nil {
        return APIResponse{
            Success:   false,
            Message:   "Validation failed",
            Error:     err.Error(),
            Timestamp: time.Now().Format(time.RFC3339),
        }, nil
    }
    
    // Create product (simulate database save)
    product := Product{
        ID:          12345,
        Name:        req.Name,
        Description: req.Description,
        Price:       req.Price,
        Category:    req.Category,
        CreatedAt:   time.Now().Format(time.RFC3339),
    }
    
    return APIResponse{
        Success:   true,
        Message:   "Product created successfully",
        Data:      product,
        Timestamp: time.Now().Format(time.RFC3339),
    }, nil
}

// Handler to get products
func GetProducts(req GetProductsRequest) (APIResponse, error) {
    // Simulate product retrieval
    products := []Product{
        {
            ID:          1,
            Name:        "Wireless Headphones",
            Description: "High-quality wireless headphones",
            Price:       99.99,
            Category:    "electronics",
            CreatedAt:   time.Now().AddDate(0, 0, -1).Format(time.RFC3339),
        },
        {
            ID:          2,
            Name:        "Programming Book",
            Description: "Learn Go programming",
            Price:       49.99,
            Category:    "books",
            CreatedAt:   time.Now().AddDate(0, 0, -2).Format(time.RFC3339),
        },
    }
    
    // Apply category filter if specified
    if req.Category != "" {
        var filtered []Product
        for _, p := range products {
            if p.Category == req.Category {
                filtered = append(filtered, p)
            }
        }
        products = filtered
    }
    
    // Apply limit if specified
    if req.Limit > 0 && req.Limit < len(products) {
        products = products[:req.Limit]
    }
    
    return APIResponse{
        Success:   true,
        Message:   fmt.Sprintf("Found %d products", len(products)),
        Data:      products,
        Timestamp: time.Now().Format(time.RFC3339),
    }, nil
}

# Deploy greeting handler
chitac deploy \
  --name greeting-service \
  --handler CreateGreeting \
  --host myapp-lmbd.chitacloud.dev \
  --method POST \
  --path /api/greeting \
  --response-content-type application/json \
  --ttl 300 \
  --public-invoke

# Deploy user management handlers
chitac deploy \
  --name get-users \
  --handler GetUsers \
  --host myapp-lmbd.chitacloud.dev \
  --method GET \
  --path /api/users \
  --response-content-type application/json \
  --ttl 60 \
  --public-invoke

chitac deploy \
  --name create-user \
  --handler CreateUser \
  --host myapp-lmbd.chitacloud.dev \
  --method POST \
  --path /api/users \
  --response-content-type application/json \
  --ttl 300 \
  --public-invoke

# Deploy product API handlers
chitac deploy \
  --name create-product \
  --handler CreateProduct \
  --host shop-lmbd.chitacloud.dev \
  --method POST \
  --path /api/products \
  --response-content-type application/json \
  --ttl 180 \
  --public-invoke

chitac deploy \
  --name get-products \
  --handler GetProducts \
  --host shop-lmbd.chitacloud.dev \
  --method POST \
  --path /api/products/search \
  --response-content-type application/json \
  --ttl 60 \
  --public-invoke

# Environment variables automatically injected:
# - DATABASE_URL (PostgreSQL connection)
# - REDIS_URL (Redis connection)
# - PORT (usually not needed for handlers)

# Management commands
chitac status --name greeting-service    # Check status
chitac logs --name greeting-service      # View logs
chitac list                              # List deployments
chitac delete --name greeting-service    # Delete deployment