Exemplos de Código

baseUrl = rtrim($baseUrl, "/");
        $this->publicKey = $publicKey;
        $this->secretKey = $secretKey;
    }
    
    public function listarProdutos($page = 1, $perPage = 15) {
        return $this->makeRequest("GET", "/produtos?page={$page}&per_page={$perPage}");
    }
    
    public function criarProduto($produto) {
        return $this->makeRequest("POST", "/produtos", $produto);
    }
    
    public function emitirNFe($dados) {
        return $this->makeRequest("POST", "/nfe/emitir", $dados);
    }
    
    private function makeRequest($method, $endpoint, $data = null) {
        $url = $this->baseUrl . $endpoint;
        
        $headers = [
            "X-Public-Key: " . $this->publicKey,
            "X-Secret-Key: " . $this->secretKey,
            "Content-Type: application/json",
            "Accept: application/json"
        ];
        
        $ch = curl_init();
        curl_setopt_array($ch, [
            CURLOPT_URL => $url,
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_HTTPHEADER => $headers,
            CURLOPT_CUSTOMREQUEST => $method,
            CURLOPT_POSTFIELDS => $data ? json_encode($data) : null,
            CURLOPT_TIMEOUT => 30,
        ]);
        
        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        $error = curl_error($ch);
        curl_close($ch);
        
        if ($error) {
            throw new Exception("cURL Error: " . $error);
        }
        
        return [
            "status_code" => $httpCode,
            "success" => $httpCode >= 200 && $httpCode < 300,
            "data" => json_decode($response, true)
        ];
    }
}

// Exemplo de uso
$api = new DrDimAPI(
    "https://api.drdim.com.br/api/v1",
    "pk_live_abc123def456",
    "sk_live_xyz789uvw012"
);

try {
    // Listar produtos
    $produtos = $api->listarProdutos(1, 20);
    if ($produtos["success"]) {
        foreach ($produtos["data"]["data"] as $produto) {
            echo "Produto: {$produto["nome"]} - R$ {$produto["preco"]}\n";
        }
    }
    
    // Criar produto
    $novoProduto = [
        "nome" => "Produto Teste",
        "descricao" => "Descrição do produto de teste",
        "preco" => 99.90,
        "codigo_referencia" => "REF001",
        "categoria_id" => 1
    ];
    
    $resultado = $api->criarProduto($novoProduto);
    if ($resultado["success"]) {
        echo "Produto criado com ID: " . $resultado["data"]["data"]["id"];
    }
    
} catch (Exception $e) {
    echo "Erro: " . $e->getMessage();
}
?>

import requests
import json
from typing import Dict, Any, Optional

class DrDimAPI:
    def __init__(self, base_url: str, public_key: str, secret_key: str):
        self.base_url = base_url.rstrip("/")
        self.public_key = public_key
        self.secret_key = secret_key
        self.session = requests.Session()
        self.session.headers.update({
            "X-Public-Key": self.public_key,
            "X-Secret-Key": self.secret_key,
            "Content-Type": "application/json",
            "Accept": "application/json"
        })
    
    def listar_produtos(self, page: int = 1, per_page: int = 15) -> Dict[str, Any]:
        """Lista produtos com paginação."""
        try:
            response = self.session.get(
                f"{self.base_url}/produtos",
                params={"page": page, "per_page": per_page},
                timeout=30
            )
            
            return {
                "status_code": response.status_code,
                "success": response.status_code < 400,
                "data": response.json()
            }
        except requests.exceptions.RequestException as e:
            return {
                "status_code": 0,
                "success": False,
                "error": str(e)
            }
    
    def criar_produto(self, produto: Dict[str, Any]) -> Dict[str, Any]:
        """Cria um novo produto."""
        try:
            response = self.session.post(
                f"{self.base_url}/produtos",
                json=produto,
                timeout=30
            )
            
            return {
                "status_code": response.status_code,
                "success": response.status_code < 400,
                "data": response.json()
            }
        except requests.exceptions.RequestException as e:
            return {
                "status_code": 0,
                "success": False,
                "error": str(e)
            }
    
    def emitir_nfe(self, dados: Dict[str, Any]) -> Dict[str, Any]:
        """Emite uma nota fiscal eletrônica."""
        try:
            response = self.session.post(
                f"{self.base_url}/nfe/emitir",
                json=dados,
                timeout=60  # NFe pode demorar mais
            )
            
            return {
                "status_code": response.status_code,
                "success": response.status_code < 400,
                "data": response.json()
            }
        except requests.exceptions.RequestException as e:
            return {
                "status_code": 0,
                "success": False,
                "error": str(e)
            }
    
    def sincronizar_produtos(self, produtos: list) -> Dict[str, Any]:
        """Sincroniza produtos em lote."""
        try:
            response = self.session.post(
                f"{self.base_url}/produtos/sync",
                json={"produtos": produtos},
                timeout=120  # Sync pode demorar
            )
            
            return {
                "status_code": response.status_code,
                "success": response.status_code < 400,
                "data": response.json()
            }
        except requests.exceptions.RequestException as e:
            return {
                "status_code": 0,
                "success": False,
                "error": str(e)
            }

# Exemplo de uso
if __name__ == "__main__":
    api = DrDimAPI(
        base_url="https://api.drdim.com.br/api/v1",
        public_key="pk_live_abc123def456",
        secret_key="sk_live_xyz789uvw012"
    )
    
    # Listar produtos
    produtos_response = api.listar_produtos(page=1, per_page=20)
    if produtos_response["success"]:
        produtos = produtos_response["data"]["data"]
        for produto in produtos:
            print(f"Produto: {produto['nome']} - R$ {produto['preco']}")
    else:
        print(f"Erro ao listar produtos: {produtos_response.get('error', 'Erro desconhecido')}")
    
    # Criar produto
    novo_produto = {
        "nome": "Produto Python",
        "descricao": "Produto criado via SDK Python",
        "preco": 149.90,
        "codigo_referencia": "PY001",
        "categoria_id": 2
    }
    
    resultado = api.criar_produto(novo_produto)
    if resultado["success"]:
        produto_id = resultado["data"]["data"]["id"]
        print(f"Produto criado com ID: {produto_id}")
    else:
        print(f"Erro ao criar produto: {resultado.get('error', 'Erro desconhecido')}")

const axios = require("axios");

class DrDimAPI {
    constructor(baseUrl, publicKey, secretKey) {
        this.baseUrl = baseUrl.replace(/\/$/, "");
        this.client = axios.create({
            baseURL: this.baseUrl,
            timeout: 30000,
            headers: {
                "X-Public-Key": publicKey,
                "X-Secret-Key": secretKey,
                "Content-Type": "application/json",
                "Accept": "application/json"
            }
        });
    }

    async listarProdutos(page = 1, perPage = 15) {
        try {
            const response = await this.client.get("/produtos", {
                params: { page, per_page: perPage }
            });
            
            return {
                success: true,
                statusCode: response.status,
                data: response.data
            };
        } catch (error) {
            return {
                success: false,
                statusCode: error.response?.status || 0,
                error: error.response?.data || error.message
            };
        }
    }

    async criarProduto(produto) {
        try {
            const response = await this.client.post("/produtos", produto);
            
            return {
                success: true,
                statusCode: response.status,
                data: response.data
            };
        } catch (error) {
            return {
                success: false,
                statusCode: error.response?.status || 0,
                error: error.response?.data || error.message
            };
        }
    }

    async emitirNFe(dados) {
        try {
            const response = await this.client.post("/nfe/emitir", dados, {
                timeout: 60000 // NFe pode demorar mais
            });
            
            return {
                success: true,
                statusCode: response.status,
                data: response.data
            };
        } catch (error) {
            return {
                success: false,
                statusCode: error.response?.status || 0,
                error: error.response?.data || error.message
            };
        }
    }

    async sincronizarProdutos(produtos) {
        try {
            const response = await this.client.post("/produtos/sync", 
                { produtos }, 
                { timeout: 120000 } // Sync pode demorar
            );
            
            return {
                success: true,
                statusCode: response.status,
                data: response.data
            };
        } catch (error) {
            return {
                success: false,
                statusCode: error.response?.status || 0,
                error: error.response?.data || error.message
            };
        }
    }
}

// Exemplo de uso
async function exemploUso() {
    const api = new DrDimAPI(
        "https://api.drdim.com.br/api/v1",
        "pk_live_abc123def456",
        "sk_live_xyz789uvw012"
    );

    try {
        // Listar produtos
        const produtos = await api.listarProdutos(1, 20);
        if (produtos.success) {
            console.log(`Encontrados ${produtos.data.data.length} produtos:`);
            produtos.data.data.forEach(produto => {
                console.log(`- ${produto.nome}: R$ ${produto.preco}`);
            });
        } else {
            console.error("Erro ao listar produtos:", produtos.error);
        }

        // Criar produto
        const novoProduto = {
            nome: "Produto Node.js",
            descricao: "Produto criado via SDK Node.js",
            preco: 199.90,
            codigo_referencia: "NODE001",
            categoria_id: 3
        };

        const resultado = await api.criarProduto(novoProduto);
        if (resultado.success) {
            console.log(`Produto criado com ID: ${resultado.data.data.id}`);
        } else {
            console.error("Erro ao criar produto:", resultado.error);
        }

        // Emitir NFe (exemplo)
        const dadosNFe = {
            cliente_id: 123,
            produtos: [
                {
                    produto_id: 456,
                    quantidade: 2,
                    valor_unitario: 99.90
                }
            ],
            desconto: 0,
            observacoes: "Venda via API"
        };

        const nfe = await api.emitirNFe(dadosNFe);
        if (nfe.success) {
            console.log(`NFe emitida: ${nfe.data.data.numero}`);
        } else {
            console.error("Erro ao emitir NFe:", nfe.error);
        }

    } catch (error) {
        console.error("Erro geral:", error.message);
    }
}

// Executar exemplo
exemploUso();

// Para uso em browser (sem Node.js)
if (typeof window !== "undefined") {
    // Usar fetch API em vez de axios
    class DrDimAPIBrowser {
        constructor(baseUrl, publicKey, secretKey) {
            this.baseUrl = baseUrl.replace(/\/$/, "");
            this.headers = {
                "X-Public-Key": publicKey,
                "X-Secret-Key": secretKey,
                "Content-Type": "application/json",
                "Accept": "application/json"
            };
        }

        async listarProdutos(page = 1, perPage = 15) {
            try {
                const url = new URL(`${this.baseUrl}/produtos`);
                url.searchParams.append("page", page);
                url.searchParams.append("per_page", perPage);

                const response = await fetch(url, {
                    method: "GET",
                    headers: this.headers
                });

                return {
                    success: response.ok,
                    statusCode: response.status,
                    data: await response.json()
                };
            } catch (error) {
                return {
                    success: false,
                    statusCode: 0,
                    error: error.message
                };
            }
        }

        async criarProduto(produto) {
            try {
                const response = await fetch(`${this.baseUrl}/produtos`, {
                    method: "POST",
                    headers: this.headers,
                    body: JSON.stringify(produto)
                });

                return {
                    success: response.ok,
                    statusCode: response.status,
                    data: await response.json()
                };
            } catch (error) {
                return {
                    success: false,
                    statusCode: 0,
                    error: error.message
                };
            }
        }
    }

    // Disponibilizar globalmente
    window.DrDimAPI = DrDimAPIBrowser;
}

import java.io.*;
import java.net.*;
import java.util.*;
import java.util.concurrent.TimeUnit;
import com.google.gson.*;

public class DrDimAPI {
    private final String baseUrl;
    private final String publicKey;
    private final String secretKey;
    private final Gson gson;
    
    public DrDimAPI(String baseUrl, String publicKey, String secretKey) {
        this.baseUrl = baseUrl.replaceAll("/$", "");
        this.publicKey = publicKey;
        this.secretKey = secretKey;
        this.gson = new GsonBuilder()
            .setDateFormat("yyyy-MM-dd HH:mm:ss")
            .create();
    }
    
    public APIResponse listarProdutos(int page, int perPage) throws IOException {
        String endpoint = String.format("/produtos?page=%d&per_page=%d", page, perPage);
        return makeRequest("GET", endpoint, null);
    }
    
    public APIResponse criarProduto(Map produto) throws IOException {
        return makeRequest("POST", "/produtos", produto);
    }
    
    public APIResponse emitirNFe(Map dados) throws IOException {
        return makeRequest("POST", "/nfe/emitir", dados);
    }
    
    public APIResponse sincronizarProdutos(List> produtos) throws IOException {
        Map payload = new HashMap<>();
        payload.put("produtos", produtos);
        return makeRequest("POST", "/produtos/sync", payload);
    }
    
    private APIResponse makeRequest(String method, String endpoint, Map data) 
            throws IOException {
        URL url = new URL(baseUrl + endpoint);
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        
        // Configurar conexão
        conn.setRequestMethod(method);
        conn.setRequestProperty("X-Public-Key", publicKey);
        conn.setRequestProperty("X-Secret-Key", secretKey);
        conn.setRequestProperty("Content-Type", "application/json");
        conn.setRequestProperty("Accept", "application/json");
        conn.setConnectTimeout(30000); // 30 segundos
        conn.setReadTimeout(60000);    // 60 segundos
        conn.setDoOutput(true);
        
        // Enviar dados se necessário
        if (data != null && !method.equals("GET")) {
            try (OutputStreamWriter writer = new OutputStreamWriter(conn.getOutputStream(), "UTF-8")) {
                writer.write(gson.toJson(data));
                writer.flush();
            }
        }
        
        int responseCode = conn.getResponseCode();
        boolean success = responseCode >= 200 && responseCode < 400;
        
        // Ler resposta
        String responseBody;
        try (BufferedReader reader = new BufferedReader(
                new InputStreamReader(
                    success ? conn.getInputStream() : conn.getErrorStream(),
                    "UTF-8"
                )
        )) {
            StringBuilder response = new StringBuilder();
            String line;
            while ((line = reader.readLine()) != null) {
                response.append(line);
            }
            responseBody = response.toString();
        }
        
        // Parsear JSON
        Map responseData = null;
        if (!responseBody.isEmpty()) {
            try {
                responseData = gson.fromJson(responseBody, Map.class);
            } catch (JsonSyntaxException e) {
                // Se não conseguir parsear como JSON, criar mapa com texto
                responseData = new HashMap<>();
                responseData.put("raw_response", responseBody);
                responseData.put("parse_error", e.getMessage());
            }
        }
        
        return new APIResponse(responseCode, success, responseData);
    }
    
    // Classe para encapsular resposta
    public static class APIResponse {
        public final int statusCode;
        public final boolean success;
        public final Map data;
        
        public APIResponse(int statusCode, boolean success, Map data) {
            this.statusCode = statusCode;
            this.success = success;
            this.data = data != null ? data : new HashMap<>();
        }
        
        @SuppressWarnings("unchecked")
        public  T getData(String key) {
            return (T) data.get(key);
        }
        
        @SuppressWarnings("unchecked")
        public Map getDataMap() {
            return (Map) data.get("data");
        }
        
        public String getMessage() {
            return (String) data.get("message");
        }
        
        public Map getErrors() {
            return (Map) data.get("errors");
        }
    }
}

// Exemplo de uso
public class ExemploUso {
    public static void main(String[] args) {
        DrDimAPI api = new DrDimAPI(
            "https://api.drdim.com.br/api/v1",
            "pk_live_abc123def456",
            "sk_live_xyz789uvw012"
        );
        
        try {
            // Listar produtos
            System.out.println("=== Listando Produtos ===");
            DrDimAPI.APIResponse produtos = api.listarProdutos(1, 20);
            
            if (produtos.success) {
                Map dataMap = produtos.getDataMap();
                if (dataMap != null && dataMap.containsKey("data")) {
                    List> produtosList = 
                        (List>) dataMap.get("data");
                    
                    System.out.println("Produtos encontrados: " + produtosList.size());
                    for (Map produto : produtosList) {
                        System.out.printf("- %s: R$ %.2f%n", 
                            produto.get("nome"), 
                            ((Number) produto.get("preco")).doubleValue()
                        );
                    }
                }
            } else {
                System.err.println("Erro ao listar produtos: " + produtos.getMessage());
                if (produtos.getErrors() != null) {
                    produtos.getErrors().forEach((campo, erros) -> 
                        System.err.println("  " + campo + ": " + erros)
                    );
                }
            }
            
            // Criar produto
            System.out.println("\n=== Criando Produto ===");
            Map novoProduto = new HashMap<>();
            novoProduto.put("nome", "Produto Java");
            novoProduto.put("descricao", "Produto criado via SDK Java");
            novoProduto.put("preco", 399.90);
            novoProduto.put("codigo_referencia", "JAVA001");
            novoProduto.put("categoria_id", 5);
            
            DrDimAPI.APIResponse resultado = api.criarProduto(novoProduto);
            
            if (resultado.success) {
                Map produtoCriado = resultado.getDataMap();
                if (produtoCriado != null) {
                    System.out.println("Produto criado com ID: " + produtoCriado.get("id"));
                    System.out.println("Nome: " + produtoCriado.get("nome"));
                }
            } else {
                System.err.println("Erro ao criar produto: " + resultado.getMessage());
                if (resultado.getErrors() != null) {
                    resultado.getErrors().forEach((campo, erros) -> 
                        System.err.println("  " + campo + ": " + erros)
                    );
                }
            }
            
            // Emitir NFe (exemplo)
            System.out.println("\n=== Emitindo NFe ===");
            Map dadosNFe = new HashMap<>();
            dadosNFe.put("cliente_id", 123);
            
            List> produtosNFe = new ArrayList<>();
            Map itemNFe = new HashMap<>();
            itemNFe.put("produto_id", 456);
            itemNFe.put("quantidade", 2);
            itemNFe.put("valor_unitario", 99.90);
            produtosNFe.add(itemNFe);
            
            dadosNFe.put("produtos", produtosNFe);
            dadosNFe.put("desconto", 0);
            dadosNFe.put("observacoes", "Venda via API Java");
            
            DrDimAPI.APIResponse nfe = api.emitirNFe(dadosNFe);
            
            if (nfe.success) {
                Map nfeCriada = nfe.getDataMap();
                if (nfeCriada != null) {
                    System.out.println("NFe emitida com número: " + nfeCriada.get("numero"));
                    System.out.println("Chave de acesso: " + nfeCriada.get("chave_acesso"));
                }
            } else {
                System.err.println("Erro ao emitir NFe: " + nfe.getMessage());
            }
            
        } catch (IOException e) {
            System.err.println("Erro de comunicação: " + e.getMessage());
            e.printStackTrace();
        } catch (Exception e) {
            System.err.println("Erro inesperado: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

namespace DrDimAPI
{
    public class DrDimApiClient
    {
        private readonly string _baseUrl;
        private readonly string _publicKey;
        private readonly string _secretKey;
        private readonly HttpClient _httpClient;
        private readonly JsonSerializerOptions _jsonOptions;

        public DrDimApiClient(string baseUrl, string publicKey, string secretKey)
        {
            _baseUrl = baseUrl.TrimEnd('/');
            _publicKey = publicKey;
            _secretKey = secretKey;
            
            _httpClient = new HttpClient
            {
                Timeout = TimeSpan.FromSeconds(60)
            };
            
            _httpClient.DefaultRequestHeaders.Add("X-Public-Key", _publicKey);
            _httpClient.DefaultRequestHeaders.Add("X-Secret-Key", _secretKey);
            _httpClient.DefaultRequestHeaders.Accept.Add(
                new MediaTypeWithQualityHeaderValue("application/json")
            );
            
            _jsonOptions = new JsonSerializerOptions
            {
                PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
                PropertyNameCaseInsensitive = true,
                WriteIndented = true
            };
        }

        public async Task ListarProdutosAsync(int page = 1, int perPage = 20)
        {
            string endpoint = $"/produtos?page={page}&per_page={perPage}";
            return await MakeRequestAsync(HttpMethod.Get, endpoint);
        }

        public async Task CriarProdutoAsync(Dictionary produto)
        {
            return await MakeRequestAsync(HttpMethod.Post, "/produtos", produto);
        }

        public async Task AtualizarProdutoAsync(int id, Dictionary produto)
        {
            return await MakeRequestAsync(HttpMethod.Put, $"/produtos/{id}", produto);
        }

        public async Task EmitirNFeAsync(Dictionary dados)
        {
            return await MakeRequestAsync(HttpMethod.Post, "/nfe/emitir", dados);
        }

        public async Task SincronizarProdutosAsync(List> produtos)
        {
            var payload = new Dictionary
            {
                { "produtos", produtos }
            };
            return await MakeRequestAsync(HttpMethod.Post, "/produtos/sync", payload);
        }

        private async Task MakeRequestAsync(
            HttpMethod method, 
            string endpoint, 
            object data = null)
        {
            try
            {
                var url = $"{_baseUrl}{endpoint}";
                var request = new HttpRequestMessage(method, url);

                if (data != null && method != HttpMethod.Get)
                {
                    var jsonContent = JsonSerializer.Serialize(data, _jsonOptions);
                    request.Content = new StringContent(
                        jsonContent, 
                        Encoding.UTF8, 
                        "application/json"
                    );
                }

                var response = await _httpClient.SendAsync(request);
                var responseBody = await response.Content.ReadAsStringAsync();

                Dictionary responseData = null;
                if (!string.IsNullOrEmpty(responseBody))
                {
                    try
                    {
                        responseData = JsonSerializer.Deserialize>(
                            responseBody, 
                            _jsonOptions
                        );
                    }
                    catch (JsonException ex)
                    {
                        responseData = new Dictionary
                        {
                            { "raw_response", responseBody },
                            { "parse_error", ex.Message }
                        };
                    }
                }

                return new ApiResponse(
                    (int)response.StatusCode,
                    response.IsSuccessStatusCode,
                    responseData
                );
            }
            catch (HttpRequestException ex)
            {
                return new ApiResponse(
                    0,
                    false,
                    new Dictionary
                    {
                        { "error", "Erro de conexão" },
                        { "message", ex.Message }
                    }
                );
            }
            catch (TaskCanceledException ex)
            {
                return new ApiResponse(
                    0,
                    false,
                    new Dictionary
                    {
                        { "error", "Timeout na requisição" },
                        { "message", ex.Message }
                    }
                );
            }
        }

        public void Dispose()
        {
            _httpClient?.Dispose();
        }
    }

    public class ApiResponse
    {
        public int StatusCode { get; }
        public bool Success { get; }
        public Dictionary Data { get; }

        public ApiResponse(int statusCode, bool success, Dictionary data)
        {
            StatusCode = statusCode;
            Success = success;
            Data = data ?? new Dictionary();
        }

        public T GetData(string key)
        {
            if (Data.TryGetValue(key, out var value))
            {
                if (value is JsonElement jsonElement)
                {
                    return JsonSerializer.Deserialize(jsonElement.ToString());
                }
                return (T)value;
            }
            return default;
        }

        public Dictionary GetDataMap()
        {
            return GetData>("data");
        }

        public string GetMessage()
        {
            return GetData("message");
        }

        public Dictionary GetErrors()
        {
            return GetData>("errors");
        }
    }
}

// Exemplo de uso
class Program
{
    static async Task Main(string[] args)
    {
        var api = new DrDimAPI.DrDimApiClient(
            "https://api.drdim.com.br/api/v1",
            "pk_live_abc123def456",
            "sk_live_xyz789uvw012"
        );

        try
        {
            // Listar produtos
            Console.WriteLine("=== Listando Produtos ===");
            var produtos = await api.ListarProdutosAsync(1, 20);

            if (produtos.Success)
            {
                var dataMap = produtos.GetDataMap();
                if (dataMap != null && dataMap.ContainsKey("data"))
                {
                    var produtosList = produtos.GetData>>("data");
                    if (produtosList != null)
                    {
                        Console.WriteLine($"Total de produtos: {produtosList.Count}");
                        foreach (var produto in produtosList)
                        {
                            Console.WriteLine($"- ID: {produto["id"]}, Nome: {produto["nome"]}");
                        }
                    }
                }
            }
            else
            {
                Console.WriteLine($"Erro: {produtos.GetMessage()}");
            }

            // Criar novo produto
            Console.WriteLine("\n=== Criando Novo Produto ===");
            var novoProduto = new Dictionary
            {
                { "nome", "Produto Teste C#" },
                { "descricao", "Criado via API C#" },
                { "preco", 149.90 },
                { "codigo_barras", "7891234567890" },
                { "estoque", 100 },
                { "categoria_id", 5 },
                { "ativo", true }
            };

            var resultado = await api.CriarProdutoAsync(novoProduto);

            if (resultado.Success)
            {
                var produtoCriado = resultado.GetDataMap();
                if (produtoCriado != null)
                {
                    Console.WriteLine($"Produto criado com ID: {produtoCriado["id"]}");
                }
            }
            else
            {
                Console.WriteLine($"Erro ao criar produto: {resultado.GetMessage()}");
                
                var errors = resultado.GetErrors();
                if (errors != null)
                {
                    foreach (var error in errors)
                    {
                        Console.WriteLine($"- {error.Key}: {error.Value}");
                    }
                }
            }

            // Emitir NFe
            Console.WriteLine("\n=== Emitindo NFe ===");
            var dadosNFe = new Dictionary
            {
                { "cliente_id", 123 },
                { "produtos", new List>
                    {
                        new Dictionary
                        {
                            { "produto_id", 456 },
                            { "quantidade", 2 },
                            { "valor_unitario", 99.90 }
                        }
                    }
                },
                { "desconto", 0 },
                { "observacoes", "Venda via API C#" }
            };

            var nfe = await api.EmitirNFeAsync(dadosNFe);

            if (nfe.Success)
            {
                var nfeCriada = nfe.GetDataMap();
                if (nfeCriada != null)
                {
                    Console.WriteLine($"NFe emitida com número: {nfeCriada["numero"]}");
                    Console.WriteLine($"Chave de acesso: {nfeCriada["chave_acesso"]}");
                }
            }
            else
            {
                Console.WriteLine($"Erro ao emitir NFe: {nfe.GetMessage()}");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Erro inesperado: {ex.Message}");
            Console.WriteLine(ex.StackTrace);
        }
        finally
        {
            api.Dispose();
        }
    }
}

require "net/http"
require "json"
require "uri"
require "openssl"

class DrDimAPI
  def initialize(base_url, public_key, secret_key)
    @base_url = base_url.chomp("/")
    @public_key = public_key
    @secret_key = secret_key
  end

  def listar_produtos(page = 1, per_page = 15)
    make_request("GET", "/produtos?page=#{page}&per_page=#{per_page}")
  end

  def criar_produto(produto)
    make_request("POST", "/produtos", produto)
  end

  def emitir_nfe(dados)
    make_request("POST", "/nfe/emitir", dados)
  end

  def sincronizar_produtos(produtos)
    make_request("POST", "/produtos/sync", { produtos: produtos })
  end

  private

  def make_request(method, endpoint, data = nil)
    uri = URI("#{@base_url}#{endpoint}")
    
    http = Net::HTTP.new(uri.host, uri.port)
    
    # Configurar SSL se necessário
    if uri.scheme == "https"
      http.use_ssl = true
      http.verify_mode = OpenSSL::SSL::VERIFY_PEER
    end
    
    # Configurar timeouts
    http.open_timeout = 30
    http.read_timeout = 60
    
    # Criar requisição
    case method.upcase
    when "GET"
      request = Net::HTTP::Get.new(uri)
    when "POST"
      request = Net::HTTP::Post.new(uri)
      request.body = data.to_json if data
    when "PUT"
      request = Net::HTTP::Put.new(uri)
      request.body = data.to_json if data
    when "DELETE"
      request = Net::HTTP::Delete.new(uri)
    else
      raise ArgumentError, "Método HTTP não suportado: #{method}"
    end
    
    # Configurar headers
    request["X-Public-Key"] = @public_key
    request["X-Secret-Key"] = @secret_key
    request["Content-Type"] = "application/json"
    request["Accept"] = "application/json"
    request["User-Agent"] = "DrDimAPI Ruby/1.0.0"
    
    begin
      response = http.request(request)
      
      {
        status_code: response.code.to_i,
        success: response.code.to_i >= 200 && response.code.to_i < 400,
        data: parse_response_body(response.body),
        headers: response.to_hash
      }
    rescue StandardError => e
      {
        status_code: 0,
        success: false,
        error: e.message,
        data: nil
      }
    end
  end
  
  def parse_response_body(body)
    return nil if body.nil? || body.empty?
    
    JSON.parse(body)
  rescue JSON::ParserError => e
    { 
      parse_error: e.message, 
      raw_response: body 
    }
  end
end

# Classe para tratar respostas de forma mais elegante
class APIResponse
  attr_reader :status_code, :success, :data, :error, :headers

  def initialize(response_hash)
    @status_code = response_hash[:status_code]
    @success = response_hash[:success]
    @data = response_hash[:data]
    @error = response_hash[:error]
    @headers = response_hash[:headers]
  end

  def success?
    @success
  end

  def failure?
    !@success
  end

  def message
    @data&.dig("message")
  end

  def response_data
    @data&.dig("data")
  end

  def errors
    @data&.dig("errors")
  end

  def meta
    @data&.dig("meta")
  end

  def pagination_info
    return nil unless meta
    
    {
      current_page: meta["current_page"],
      per_page: meta["per_page"],
      total: meta["total"],
      last_page: meta["last_page"]
    }
  end
end

# Wrapper para facilitar o uso
class DrDimAPIClient
  def initialize(base_url, public_key, secret_key)
    @api = DrDimAPI.new(base_url, public_key, secret_key)
  end

  def listar_produtos(page: 1, per_page: 15)
    response = @api.listar_produtos(page, per_page)
    APIResponse.new(response)
  end

  def criar_produto(produto)
    response = @api.criar_produto(produto)
    APIResponse.new(response)
  end

  def emitir_nfe(dados)
    response = @api.emitir_nfe(dados)
    APIResponse.new(response)
  end

  def sincronizar_produtos(produtos)
    response = @api.sincronizar_produtos(produtos)
    APIResponse.new(response)
  end
end

# Exemplo de uso
if __FILE__ == $0
  # Inicializar cliente
  client = DrDimAPIClient.new(
    "https://api.drdim.com.br/api/v1",
    "pk_live_abc123def456",
    "sk_live_xyz789uvw012"
  )

  begin
    # Listar produtos
    puts "=== Listando Produtos ==="
    produtos_response = client.listar_produtos(page: 1, per_page: 20)
    
    if produtos_response.success?
      produtos = produtos_response.response_data || []
      puts "Produtos encontrados: #{produtos.length}"
      
      produtos.each do |produto|
        puts "- #{produto['nome']}: R$ #{produto['preco']}"
      end
      
      # Informações de paginação
      if produtos_response.pagination_info
        pagination = produtos_response.pagination_info
        puts "Página #{pagination[:current_page]} de #{pagination[:last_page]}"
        puts "Total: #{pagination[:total]} produtos"
      end
    else
      puts "Erro ao listar produtos: #{produtos_response.message || produtos_response.error}"
      
      if produtos_response.errors
        produtos_response.errors.each do |campo, mensagens|
          puts "  #{campo}: #{mensagens.join(', ')}"
        end
      end
    end

    # Criar produto
    puts "\n=== Criando Produto ==="
    novo_produto = {
      nome: "Produto Ruby",
      descricao: "Produto criado via SDK Ruby",
      preco: 299.90,
      codigo_referencia: "RUBY001",
      categoria_id: 4
    }

    resultado = client.criar_produto(novo_produto)
    
    if resultado.success?
      produto_criado = resultado.response_data
      puts "Produto criado com ID: #{produto_criado['id']}"
      puts "Nome: #{produto_criado['nome']}"
    else
      puts "Erro ao criar produto: #{resultado.message || resultado.error}"
      
      if resultado.errors
        resultado.errors.each do |campo, mensagens|
          puts "  #{campo}: #{mensagens.join(', ')}"
        end
      end
    end

    # Emitir NFe (exemplo)
    puts "\n=== Emitindo NFe ==="
    dados_nfe = {
      cliente_id: 123,
      produtos: [
        {
          produto_id: 456,
          quantidade: 2,
          valor_unitario: 99.90
        }
      ],
      desconto: 0,
      observacoes: "Venda via API Ruby"
    }

    nfe_response = client.emitir_nfe(dados_nfe)
    
    if nfe_response.success?
      nfe = nfe_response.response_data
      puts "NFe emitida com número: #{nfe['numero']}"
      puts "Chave de acesso: #{nfe['chave_acesso']}" if nfe['chave_acesso']
    else
      puts "Erro ao emitir NFe: #{nfe_response.message || nfe_response.error}"
    end

  rescue StandardError => e
    puts "Erro inesperado: #{e.message}"
    puts e.backtrace.join("\n") if $DEBUG
  end
end