import type { Prettify } from 'ts-essentials';
import type { Address } from '../../types';
import type { TypedDataField } from '../common/orders/buildOrderData';
import type {
  Bridge,
  DeltaOrderType,
  DeltaOrderUnion,
  OnChainOrderMap,
  OnChainOrderType,
} from './helpers/types';

/** @description Response from POST /v2/delta/orders/build — EIP-712 typed data ready to sign. */
export type BuiltDeltaOrder<T extends DeltaOrderUnion = DeltaOrderUnion> = {
  toSign: {
    domain: {
      name: string;
      version: string;
      chainId: number;
      verifyingContract: string;
    };
    /** EIP-712 type definitions keyed by type name. */
    types: Record<string, TypedDataField[]>;
    /** The on-chain order struct value to sign. */
    value: T;
  };
  /** EIP-712 order hash. */
  orderHash: string;
};

/** @description Token identity used across v2 endpoints. */
export type DeltaPriceToken = {
  chainId: number;
  address: Address;
};

/** @description A token amount with its USD value, used uniformly for inputs, outputs, and fees. */
export type DeltaTokenAmount = {
  token: DeltaPriceToken;
  /** @description Amount in wei. */
  amount: string;
  /** @description USD value of the amount. */
  amountUSD: string;
};

/** @description Bridge tag used to mark routes as recommended / fastest / best-return. */
export type BridgeTag = 'recommended' | 'fastest' | 'best-return';

/** @description Subset of the on-chain Bridge struct returned in v2 price responses.
 *  (the full `route` object is passed to the server when building an order). */
export type DeltaRouteBridgeContractParams = Omit<Bridge, 'destinationChainId'>;

/** @description Bridge details on a route. Same-chain routes carry `null` for `route.bridge`. */
export type DeltaRouteBridge = {
  /** @description Bridge protocol identifier (e.g. "Across", "Relay", "Mayan"). */
  protocol: string;
  /** @description Estimated bridging time in milliseconds. */
  estimatedTimeMs: number;
  /** @description Tags for this route ("recommended", "fastest", "best-return"). May be empty. */
  tags: BridgeTag[];
  /** @description Bridge contract parameters as returned by the server. */
  contractParams: DeltaRouteBridgeContractParams;
};

/** @description A single step of a route (origin chain or destination chain). */
export type DeltaRouteStep = {
  /** @description The token amount entering this step (before any per-step swap). */
  input: DeltaTokenAmount;
  /** @description The token amount exiting this step (after any per-step swap). */
  output: DeltaTokenAmount;
};

/** @description A route describes how the swap flows from origin chain to destination chain. */
export type DeltaRoute = {
  /** @description Source-chain step. The on-chain Delta order's amounts come from `origin.input` and `origin.output`. */
  origin: DeltaRouteStep;
  /** @description Destination-chain step. For same-chain routes this mirrors `origin`. */
  destination: DeltaRouteStep;
  /** @description Bridge details. `null` for same-chain routes. */
  bridge: DeltaRouteBridge | null;
  /** @description Fee breakdown for this route. */
  fees: {
    /** @description Gas fee (single DeltaTokenAmount on the source chain). */
    gas: DeltaTokenAmount;
    /** @description Bridge fees (empty array for same-chain). */
    bridge: DeltaTokenAmount[];
  };
};

/** @description v2 price response: route-based, cross-chain first. */
export type DeltaPrice = {
  /** @description Unique request ID for tracing. */
  id: string;
  /** @description Order side. */
  side: 'SELL' | 'BUY';
  /** @description Token the user trades (identity only — amounts live in route.origin.input). */
  inputToken: DeltaPriceToken;
  /** @description Token the user receives (identity only — amounts live in route.destination.output). */
  outputToken: DeltaPriceToken;
  /** @description Recommended route with full amounts and bridge details. */
  route: DeltaRoute;
  /** @description Partner info attached to this price. */
  partner: {
    name: string;
    /** @description Partner fee in percent (e.g. 0.12 = 0.12%). */
    feePercent: number;
  };
  /** @description Address to approve for spending the input token. */
  spender: Address;
  /** @description Alternative routes (other bridges). Each is a full DeltaRoute. */
  alternatives: DeltaRoute[];
};

/** @description
 * A flat bridge-routes entry returned by GET /v2/delta/prices/bridge-routes (better version of v1 prices/bridge-info).
 * Can be used to populate bridge selection UIs and to validate that bridge is possible for a given src/dest pair before calling GET /v2/delta/prices.
 * */
export type BridgeRoute = {
  srcChainId: number;
  destChainId: number;
  /** @description Output tokens supported on the dest chain for this src→dest pair. */
  tokens: Address[];
};

/* ------------------------------------------------------------------ */
/* Orders v2 response shape: DeltaAuction<T>, same generic shape as     */
/* v1's DeltaAuction but with v2 base fields.                           */
/* ------------------------------------------------------------------ */

/** @description Integrator-facing order status returned by v2 order endpoints. */
const DeltaOrderStatusMap = {
  Pending: 'PENDING',
  AwaitingSignature: 'AWAITING_SIGNATURE',
  Active: 'ACTIVE',
  Suspended: 'SUSPENDED',
  Cancelling: 'CANCELLING',
  Bridging: 'BRIDGING',
  Completed: 'COMPLETED',
  Failed: 'FAILED',
  Expired: 'EXPIRED',
  Cancelled: 'CANCELLED',
  Refunded: 'REFUNDED',
  Refunding: 'REFUNDING',
} as const;

export type DeltaOrderStatus =
  (typeof DeltaOrderStatusMap)[keyof typeof DeltaOrderStatusMap];

/** @description Token side on an order. SELL provides an explicit `amount`; BUY provides expected/executed amounts. */
export type DeltaTokenSide =
  | {
      chainId: number;
      token: Address;
      amount: string;
    }
  | {
      chainId: number;
      token: Address;
      expectedAmount: string | null;
      executedAmount: string | null;
    };

/** @description A single transaction entry on a v2 order. */
export type DeltaTransaction = {
  originTx: string;
  destinationTx: string | null;
  /** @description Filled percent of the slice (0–100). */
  filledPercent: number;
  spentAmount: string | null;
  receivedAmount: string | null;
};

export type BridgeRefundMetadata = {
  tx: string;
  chainId: number;
  token: Address;
  amount: string;
};

type DeltaAuctionBase = {
  id: string;
  status: DeltaOrderStatus;
  side: 'SELL' | 'BUY';
  type: DeltaOrderType;
  input: DeltaTokenSide;
  output: DeltaTokenSide;
  owner: Address;
  beneficiary: Address;
  orderHash: string;
  partner: string;
  transactions: DeltaTransaction[];
  refunds: BridgeRefundMetadata[];
  /** @description ISO datetime string. */
  createdAt: string;
  /** @description ISO datetime string. */
  updatedAt: string;
  /** @description ISO datetime string. */
  expiresAt: string;
};

/** @description Order shape returned by GET /v2/orders, /v2/orders/:id, /v2/orders/hash/:hash.
 *  Generic over `onChainOrderType` like v1's `DeltaAuction`: the type distributes over the
 *  union so that `order` narrows to the matching family (`OnChainOrderMap[T]`). */
export type DeltaAuction<T extends OnChainOrderType = OnChainOrderType> =
  T extends T
    ? Prettify<
        DeltaAuctionBase & {
          onChainOrderType: T;
          order: OnChainOrderMap[T];
        }
      >
    : never;