enum ChainType {
  BASE = 'base',
  ARBITRUM = 'arbitrum',
  ETHEREUM = 'ethereum'
}

enum SessionScope {
  READ = 'read',
  DEFI = 'defi',
  FULL = 'full'
}

enum ErrorCode {
  WALLET_NOT_CONNECTED = 'WALLET_NOT_CONNECTED',
  SMART_ACCOUNT_ERROR = 'SMART_ACCOUNT_ERROR',
  API_ERROR = 'API_ERROR',
  CONFIG_ERROR = 'CONFIG_ERROR',
  QUOTE_ERROR = 'QUOTE_ERROR',
  WORKFLOW_ERROR = 'WORKFLOW_ERROR',
  STORAGE_ERROR = 'STORAGE_ERROR',
  NETWORK_ERROR = 'NETWORK_ERROR',
  VALIDATION_ERROR = 'VALIDATION_ERROR'
}

interface BorrowSDKConfig {
  // Required
  apiKey: string;
  baseUrl: string;
  chain: ChainType;
  wallet: WalletProvider;

  // Optional
  rpcUrl?: string;
  bundlerUrl?: string;
  storage?: StorageProvider;
  workflowPollInterval?: number;
  sessionValiditySeconds?: number;
  autoTrackWorkflows?: boolean;
  quoteSelector?: (quotes: Quote[]) => Quote;
  retryConfig?: RetryConfig;
  logger?: Logger;
}

interface WalletProvider {
  address: string;
  publicKey?: string;
  signMessage: (message: string) => Promise<string>;
  sendBitcoin?: (toAddress: string, satoshis: number) => Promise<string>;
}

interface StorageProvider {
  getItem(key: string): string | null;
  setItem(key: string, value: string): void;
  removeItem(key: string): void;
  clear(): void;
}

interface RetryConfig {
  maxRetries: number;
  retryDelay: number;
  retryableStatusCodes: number[];
}

interface Logger {
  debug: (message: string) => void;
  info: (message: string) => void;
  warn: (message: string) => void;
  error: (message: string) => void;
}

interface UserStatus {
  isConnected: boolean;
  btcAddress?: string;
  smartAccountAddress?: string;
  isDeployed?: boolean;
  hasActiveSession: boolean;
  sessionExpiry?: number;
}

interface ActiveSession {
  sessionKeyAddress?: string;
  sessionPrivateKey?: string;
  validUntil: number;
  authorizationSignature?: string;
  scope?: SessionScope;
}

interface QuoteRequest {
  collateralAmount: string;
  loanAmount: string;
  ltv: number;
  term?: number;
}

interface Quote {
  collateralAmount: string;
  loanAmount: string;
  protocol: string;
  chain: ChainType;
  borrowApy: {
    variable: string;
    stable: string;
  };
  effectiveApy?: {
    variable: string;
    stable: string;
  };
}

interface GetLoanOptions {
  collateralBTC: number;
  loanAmountUSD: number;
  ltv?: number;
  term?: number;
  destinationAddress?: string;
  quoteSelector?: (quotes: Quote[]) => Quote;
  onStatusUpdate?: (status: WorkflowStatus) => void;
  onDepositReady?: (info: DepositInfo) => void;
  onComplete?: (result: any) => void;
  onError?: (error: string) => void;
}

interface LoanResult {
  workflowId: string;
  quote: Quote;
  tracker: any;
  stop: () => void;
}

interface LoanCollateralInfo {
  totalCollateral: string;
  availableCollateral: string;
  maxWithdrawable: string;
  totalDebt: string;
  remainingDebt: string;
}

interface UserTransaction {
  id: string;
  type: 'borrow' | 'repay' | 'withdraw';
  status: 'pending' | 'active' | 'completed' | 'failed' | 'awaiting_deposit';
  amount: string;
  currency: string;
  txHash?: string;
  timestamp: number;
  borrowTransaction?: any;
  repayTransaction?: any;
}

interface PaginatedResponse<T> {
  transactions: T[];
  pagination: {
    totalTransactions: number;
    currentPage: number;
    limit: number;
    totalPages: number;
    hasNext: boolean;
    hasPrevious: boolean;
  };
}

interface RepayTransaction {
  _id: string;
  userId: string;
  originalBorrowId: string;
  loanChainAddress: string;
  repayAmount: string;
  withdrawalCollateralAmount: string;
  repayTokenAddress: string;
  isPartialRepay: boolean;
  isPartialWithdrawCollateral: boolean;
  useCollateral: boolean;
  workflowId?: string;
  transactionStatuses: Array<{
    status: string;
    timestamp: Date;
    details?: string;
  }>;
  repayConfig: any;
  userBtcWithdrawAddress?: string;
  bridgeConfig?: any;
  workflowState?: RepayWorkflowState;
  createdAt: Date;
  updatedAt: Date;
}

interface RepayTransactionStatusResponse {
  transactionDetails: RepayTransaction;
  transactionState?: RepayWorkflowState;
}

interface WorkflowStatus {
  stage: string;
  step: number;
  label: string;
  description: string;
  depositAddress?: string;
  depositAmount?: number;
  error?: string;
  isComplete: boolean;
  isFailed: boolean;
  rawData: any;
}

interface WorkflowCallbacks {
  onStatusUpdate?: (status: WorkflowStatus) => void;
  onComplete?: (result: any) => void;
  onError?: (error: string) => void;
  onDepositReady?: (info: DepositInfo) => void;
}

interface DepositInfo {
  address: string;
  amount: number;
  amountBTC: number;
}

interface RepayWorkflowState {
  stage: RepayWorkflowStage;
  error?: string;
  redeemTxHash?: string;
}

enum RepayWorkflowStage {
  INITIALIZING,
  TRANSFERRING_TO_KERNEL,
  REPAYING_LOAN,
  WITHDRAWING_COLLATERAL,
  TRANSFERRING_TO_PLATFORM_WALLET,
  BRIDGE_INITIALIZING,
  BRIDGE_QUOTE_READY,
  BRIDGE_SWAP_CREATED,
  BRIDGE_EXECUTING_APPROVAL,
  BRIDGE_APPROVAL_CONFIRMED,
  BRIDGE_EXECUTING_INITIATE,
  BRIDGE_INITIATE_CONFIRMED,
  BRIDGE_AWAITING_BRIDGE_COMPLETION,
  BRIDGE_COMPLETED,
  COMPLETED,
  FAILED,
  CANCELLED
}

interface WalletPosition {
  id: string;
  type: string;
  attributes: {
    parent: string | null;
    protocol: string | null;
    name: string;
    position_type: string;
    quantity: {
      int: string;
      decimals: number;
      float: number;
      numeric: string;
    };
    value: number | null;
    price: number;
    changes: {
      absolute_1d: number | null;
      percent_1d: number | null;
    } | null;
    fungible_info: {
      name: string;
      symbol: string;
      icon: { url: string } | null;
      flags: { verified: boolean };
      implementations: Array<{
        chain_id: string;
        address: string;
        decimals: number;
      }>;
    } | null;
    flags: {
      displayable: boolean;
      is_trash: boolean;
    };
    updated_at: string;
    updated_at_block: number;
  };
  relationships: {
    chain: { data: { type: string; id: string } };
  };
}

interface WalletPositionsResponse {
  data: WalletPosition[];
  links?: { self: string };
}

interface WalletPortfolio {
  id: string;
  type: string;
  attributes: {
    positions_distribution_by_type: Record<string, number>;
    positions_distribution_by_chain: Record<string, number>;
    total: { positions: number };
    changes: {
      absolute_1d: number;
      percent_1d: number;
    };
  };
}

interface WalletPortfolioResponse {
  data: WalletPortfolio;
  links?: { self: string };
}

interface FeesRequest {
  chain: ChainType;
  collateralAmount: string;
}

interface FeesResponseData {
  chain: ChainType;
  collateralAmount: string;
  gardenFeePercent: number;
  affiliateFeePercent: number;
  totalBridgeFeePercentage: number;
  totalBridgeFeeUSD: string;
  gardenFeeUSD: string;
  affiliateFeeUSD: string;
  estimatedGasFee: string;
}

interface WithdrawToBitcoinRequest {
  chain: ChainType;
  amount: string;
  assetSymbol: string;
  btcAddress: string;
}

interface WithdrawToEVMRequest {
  chain: ChainType;
  amount: string;
  destinationAddress: string;
  /** Optional wallet index. Defaults to 0 (base wallet where borrowed USDC goes). */
  loanIndex?: number;
}

interface WithdrawToEVMResponse {
  success: boolean;
  data: {
    transactionId: string;
    transactionHash: string;
    status: string;
    sourceAddress: string;
    destinationAddress: string;
    amount: string;
    chain: ChainType;
  };
}

interface WithdrawStatusResponse {
  success: boolean;
  data: WithdrawTransaction;
  transactionState?: {
    stage: string;
    redeemTxHash?: string;
    error?: string;
  };
}

// Branded types for type safety
type Satoshis = number & { readonly __brand: 'satoshis' };
type BTC = string & { readonly __brand: 'btc' };

const Units = {
  // Conversions
  satsToBtc: (sats: number) => BTC;
  btcToSats: (btc: string) => Satoshis;

  // Formatting
  formatBtc: (btc: BTC | string, decimals?: number) => string;
  formatSats: (sats: Satoshis | number) => string;

  // Type constructors
  asBtc: (value: string) => BTC;
  asSatoshis: (value: number) => Satoshis;

  // Smart normalization (handles both sats and BTC inputs)
  normalizeToBtc: (value: string | number) => BTC;
  normalizeToSats: (value: string | number) => Satoshis;

  // Detection
  isLikelySatoshis: (value: number) => boolean;
};

import { Units, type Satoshis, type BTC } from '@satsterminal-sdk/borrow';

// Basic conversions
Units.satsToBtc(10000000);           // "0.10000000" (typed as BTC)
Units.btcToSats("0.1");              // 10000000 (typed as Satoshis)

// Smart normalization (auto-detects units)
Units.normalizeToBtc(10000000);      // "0.10000000" (detected as sats)
Units.normalizeToBtc("0.1");         // "0.10000000" (detected as BTC)

// Formatting for display
Units.formatBtc("0.12345678", 4);    // "0.1235"
Units.formatSats(1234567);           // "1,234,567"

// Type-safe branded values
const sats: Satoshis = Units.asSatoshis(10000000);
const btc: BTC = Units.asBtc("0.1");

const ResponseNormalizer = {
  // Normalize quote responses from various formats
  normalizeQuotes: (response: any) => Quote[];

  // Normalize repay transaction responses
  normalizeRepayTransactions: (response: any) => RepayTransaction[];

  // Extract loan collateral info from response
  extractLoanCollateralInfo: (response: any) => LoanCollateralInfo | null;

  // Normalize borrow transaction to canonical format
  normalizeBorrowTransaction: (raw: any) => NormalizedTransaction | null;
};

import { ResponseNormalizer } from '@satsterminal-sdk/borrow';

// Handle various quote response formats
const quotes = ResponseNormalizer.normalizeQuotes(apiResponse);
// Works with: data[], { allQuotes: [] }, { data: { allQuotes: [] } }, etc.

// Extract collateral info regardless of response structure
const collateralInfo = ResponseNormalizer.extractLoanCollateralInfo(loanData);

/** @deprecated Use Units instead */
class BtcUtils {
  static satsToBtc(sats: number): string;
  static btcToSats(btc: string): number;
  /** @deprecated Use Units.normalizeToBtc() instead */
  static formatBtcDisplay(amount: string | number): string;
}

// Before (deprecated)
import { BtcUtils } from '@satsterminal-sdk/borrow';
BtcUtils.satsToBtc(10000000);
BtcUtils.formatBtcDisplay(amount);

// After (recommended)
import { Units } from '@satsterminal-sdk/borrow';
Units.satsToBtc(10000000);
Units.normalizeToBtc(amount);