import { Tuish } from '@tuish/sdk';

const tuish = new Tuish(config: TuishConfig);

import tuish "github.com/tuish/sdk-go"

sdk, err := tuish.New(config Config)

use tuish::Tuish;

let tuish = Tuish::builder()
    .product_id("prod_xxx")
    .public_key("MCowBQYDK2VwAyEA...")
    .build()?;

Tuish::builder()
    .product_id(id: &str)
    .public_key(key: &str)
    .api_key(key: &str)        // Optional
    .api_url(url: &str)        // Optional
    .build() -> Result<Tuish>

from tuish import Tuish

client = Tuish(
    product_id="prod_xxx",
    public_key="MCowBQYDK2VwAyEA...",
)

interface TuishConfig {
  productId: string;           // Required
  publicKey: string;           // Required - Ed25519 public key
  apiBaseUrl?: string;         // Default: https://api.tuish.dev
  apiKey?: string;             // For authenticated requests
  storageDir?: string;         // Default: ~/.tuish/licenses/
  debug?: boolean;             // Enable debug logging
}

type Config struct {
    ProductID  string  // Required
    PublicKey  string  // Required - Ed25519 (SPKI base64 or hex)
    APIBaseURL string  // Default: https://api.tuish.dev
    APIKey     string  // For authenticated requests
    StorageDir string  // Default: ~/.tuish/licenses/
    Debug      bool    // Enable debug logging
}

pub struct TuishConfig {
    pub product_id: String,
    pub public_key: String,
    pub api_url: String,
    pub api_key: Option<String>,
}

impl TuishConfig {
    pub fn new(product_id: &str, public_key: &str) -> Self;
}

Tuish(
    product_id: str,           # Required
    public_key: str,           # Required - Ed25519 public key
    api_base_url: str = "https://api.tuish.dev",
    api_key: str | None = None,
    storage_dir: str = "~/.tuish/licenses",
    debug: bool = False,
)

interface LicenseCheckResult {
  valid: boolean;
  license?: LicenseDetails;
  reason?: LicenseInvalidReason;
  offlineVerified: boolean;
  machineBound?: boolean;         // Whether license is bound to a machine
  machineFingerprint?: string;    // Fingerprint the license is bound to
}

interface LicenseDetails {
  id: string;
  productId: string;
  productName?: string;
  features: string[];
  status: 'active' | 'expired' | 'revoked';
  issuedAt: number;      // Unix timestamp (ms)
  expiresAt: number | null;  // null = perpetual
}

type LicenseInvalidReason =
  | 'not_found'
  | 'expired'
  | 'revoked'
  | 'invalid_format'
  | 'invalid_signature'
  | 'machine_mismatch'
  | 'network_error';

type LicenseCheckResult struct {
    Valid           bool
    License         *LicenseDetails
    Reason          LicenseInvalidReason
    OfflineVerified bool
}

type LicenseDetails struct {
    ID          string
    ProductID   string
    ProductName string
    Features    []string
    Status      LicenseStatus
    IssuedAt    int64   // Unix timestamp (ms)
    ExpiresAt   *int64  // nil = perpetual
}

const (
    ReasonNotFound         = "not_found"
    ReasonExpired          = "expired"
    ReasonRevoked          = "revoked"
    ReasonInvalidFormat    = "invalid_format"
    ReasonInvalidSignature = "invalid_signature"
    ReasonMachineMismatch  = "machine_mismatch"
    ReasonNetworkError     = "network_error"
)

pub struct LicenseCheckResult {
    pub valid: bool,
    pub license: Option<LicenseDetails>,
    pub reason: Option<LicenseInvalidReason>,
    pub offline_verified: bool,
}

pub struct LicenseDetails {
    pub id: String,
    pub product_id: String,
    pub product_name: Option<String>,
    pub features: Vec<String>,
    pub status: LicenseStatus,
    pub issued_at: i64,
    pub expires_at: Option<i64>,
}

pub enum LicenseInvalidReason {
    NotFound,
    Expired,
    Revoked,
    InvalidFormat,
    InvalidSignature,
    WrongMachine,
    NetworkError,
}

pub struct LicensePayload {
    pub lid: String,           // License ID
    pub pid: String,           // Product ID
    pub cid: String,           // Customer ID
    pub did: String,           // Developer ID
    pub features: Vec<String>,
    pub iat: i64,              // Issued at (ms)
    pub exp: Option<i64>,      // Expires at (ms)
    pub mid: Option<String>,   // Machine ID
}

impl LicensePayload {
    pub fn is_expired(&self) -> bool;
    pub fn has_feature(&self, feature: &str) -> bool;
}

interface CheckoutSession {
  sessionId: string;
  checkoutUrl: string;
}

interface CheckoutOptions {
  email?: string;
  openBrowser?: boolean;
}

interface WaitOptions {
  pollIntervalMs?: number;  // Default: 2000
  timeoutMs?: number;       // Default: 600000
  onPoll?: (status: 'pending' | 'complete' | 'expired') => void;
}

type CheckoutSession struct {
    SessionID   string
    CheckoutURL string
}

pub struct CheckoutSession {
    pub session_id: String,
    pub checkout_url: String,
}

class TuishApiError extends Error {
  statusCode: number;
  code: ErrorCode;
  details?: Record<string, unknown>;
}

type ErrorCode =
  | 'not_found'
  | 'invalid_request'
  | 'unauthorized'
  | 'forbidden'
  | 'conflict'
  | 'internal_error';

// Example handling
const result = await tuish.checkLicense();
if (!result.valid) {
  switch (result.reason) {
    case 'expired':
      console.log('License has expired');
      break;
    case 'machine_mismatch':
      console.log('License is bound to a different machine');
      break;
    // ...
  }
}

#[derive(Debug, thiserror::Error)]
pub enum TuishError {
    #[error("Invalid license: {0}")]
    InvalidLicense(String),

    #[error("License has expired")]
    ExpiredLicense,

    #[error("Invalid signature")]
    InvalidSignature,

    #[error("License is for a different machine")]
    InvalidMachineId,

    #[error("Network error: {0}")]
    NetworkError(String),

    #[error("Storage error: {0}")]
    StorageError(String),

    #[error("API error ({status}): {message}")]
    ApiError { status: u16, message: String },

    #[error("Parse error: {0}")]
    ParseError(String),

    #[error("Invalid public key: {0}")]
    InvalidPublicKey(String),

    #[error("Feature not available: {0}")]
    FeatureNotAvailable(String),
}