suiService.ts

import { resolveRpcUrl } from '@/lib/appConfig';
import { appStore } from '@/lib/store';
import {
  Network,
  ChainId,
  SuiRpcResponse,
  BuilderArg,
  RPCHealthMetric,
} from '../types';
import { EVM_NETWORKS, STELLAR_NETWORKS } from '@/lib/constants';

const RPC_TIMEOUT_MS = 10000;
const DEGRADED_RPC_LATENCY_MS = 1500;

export class SuiRpcError extends Error {
  status: number;
  endpoint: string;
  duration: number;

  constructor(
    message: string,
    {
      status,
      endpoint,
      duration,
    }: {
      status: number;
      endpoint: string;
      duration: number;
    }
  ) {
    super(message);
    this.name = 'SuiRpcError';
    this.status = status;
    this.endpoint = endpoint;
    this.duration = duration;
    Object.setPrototypeOf(this, SuiRpcError.prototype);
  }
}

export const getActiveSuiRpcUrl = (
  network: Network
) =>
  resolveRpcUrl(
    network,
    appStore.getSnapshot().settings
  );

export const resolveChainRpcUrl = (
  chain: ChainId,
  network: Network
): string => {
  if (chain === 'sui') {
    return getActiveSuiRpcUrl(network);
  }

  const map = chain === 'evm' ? EVM_NETWORKS : STELLAR_NETWORKS;
  return map[network];
};

/** Generic JSON-RPC fetch used for all chains. */
export const executeChainRpc = async (
  chain: ChainId,
  network: Network,
  method: string,
  params: any[]
): Promise<{ result: any; duration: number; status: number }> => {
  if (chain === 'sui') {
    return executeSuiRpc(network, method, params);
  }

  const url = resolveChainRpcUrl(chain, network);
  const startTime = performance.now();

  try {
    const controller = new AbortController();
    const timeoutId = setTimeout(
      () => controller.abort(),
      RPC_TIMEOUT_MS
    );

    const response = await fetch(url, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        jsonrpc: '2.0',
        id: 1,
        method,
        params,
      }),
      signal: controller.signal
    });
    clearTimeout(timeoutId);

    const data = await response.json();
    const duration = Math.round(
      performance.now() - startTime
    );

    if (!response.ok) {
      const message =
        typeof data.error?.message === 'string' && data.error.message
          ? data.error.message
          : `RPC request failed with status ${response.status}.`;
      throw new SuiRpcError(message, {
        status: response.status,
        endpoint: url,
        duration,
      });
    }

    if (data.error) {
      const message =
        typeof data.error.message === 'string' && data.error.message
          ? data.error.message
          : `${chain.toUpperCase()} RPC returned an error.`;
      throw new SuiRpcError(message, {
        status: response.status || 500,
        endpoint: url,
        duration,
      });
    }

    return {
      result: data.result,
      duration,
      status: response.status,
    };
  } catch (error: any) {
    const duration = Math.round(
      performance.now() - startTime
    );

    if (error instanceof SuiRpcError) {
      throw error;
    }

    if (error?.name === 'AbortError') {
      throw new SuiRpcError(
        `RPC request timed out after ${RPC_TIMEOUT_MS / 1000}s.`,
        { status: 504, endpoint: url, duration }
      );
    }

    throw new SuiRpcError(
      error instanceof Error && error.message.trim()
        ? error.message
        : `Unable to reach the configured ${chain.toUpperCase()} RPC endpoint.`,
      { status: 0, endpoint: url, duration }
    );
  }
};

/** Chain-aware health check: pings a lightweight method per chain. */
export const getChainRpcHealth = async (
  chain: ChainId,
  network: Network
): Promise<RPCHealthMetric> => {
  if (chain === 'sui') {
    return getSuiRpcHealth(network);
  }

  const url = resolveChainRpcUrl(chain, network);
  const method = chain === 'evm' ? 'eth_blockNumber' : 'getHealth';
  const params: any[] = chain === 'evm' ? [] : [];

  try {
    const { result, duration } =
      await executeChainRpc(chain, network, method, params);
    return {
      endpoint: url,
      latency: [duration],
      successRate: 1,
      status: duration >= DEGRADED_RPC_LATENCY_MS ? 'degraded' : 'healthy',
      blockHeight: typeof result === 'string' ? parseInt(result, 16) || 0 : Number(result) || 0,
    };
  } catch (error) {
    const rpcError = error instanceof SuiRpcError ? error : null;
    return {
      endpoint: url,
      latency: [rpcError?.duration ?? RPC_TIMEOUT_MS],
      successRate: 0,
      status: rpcError?.status === 504 ? 'degraded' : 'down',
      blockHeight: 0,
    };
  }
};

export const executeSuiRpc = async (
  network: Network,
  method: string,
  params: any[]
): Promise<{ result: any; duration: number; status: number }> => {
  const url = getActiveSuiRpcUrl(network);
  const startTime = performance.now();

  try {
    const controller = new AbortController();
    const timeoutId = setTimeout(
      () => controller.abort(),
      RPC_TIMEOUT_MS
    );

    const response = await fetch(url, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        jsonrpc: '2.0',
        id: 1,
        method,
        params,
      }),
      signal: controller.signal
    });
    clearTimeout(timeoutId);

    const data: SuiRpcResponse = await response.json();
    const duration = Math.round(
      performance.now() - startTime
    );

    if (!response.ok) {
      const message =
        typeof data.error?.message ===
          'string' && data.error.message
          ? data.error.message
          : `RPC request failed with status ${response.status}.`;

      throw new SuiRpcError(message, {
        status: response.status,
        endpoint: url,
        duration,
      });
    }

    if (data.error) {
      const message =
        typeof data.error.message ===
          'string' && data.error.message
          ? data.error.message
          : 'Sui RPC returned an error.';

      throw new SuiRpcError(message, {
        status: response.status || 500,
        endpoint: url,
        duration,
      });
    }

    return {
      result: data.result,
      duration,
      status: response.status,
    };
  } catch (error: any) {
    const duration = Math.round(
      performance.now() - startTime
    );

    if (error instanceof SuiRpcError) {
      throw error;
    }

    if (error?.name === 'AbortError') {
      throw new SuiRpcError(
        `RPC request timed out after ${RPC_TIMEOUT_MS / 1000}s.`,
        {
          status: 504,
          endpoint: url,
          duration,
        }
      );
    }

    throw new SuiRpcError(
      error instanceof Error &&
        error.message.trim()
        ? error.message
        : 'Unable to reach the configured Sui RPC endpoint.',
      {
        status: 0,
        endpoint: url,
        duration,
      }
    );
  }
};

export const getSuiRpcHealth =
  async (
    network: Network
  ): Promise<RPCHealthMetric> => {
    const endpoint =
      getActiveSuiRpcUrl(network);

    try {
      const { result, duration } =
        await executeSuiRpc(
          network,
          'sui_getLatestCheckpointSequenceNumber',
          []
        );

      const blockHeight =
        Number.parseInt(
          String(result),
          10
        ) || 0;

      return {
        endpoint,
        latency: [duration],
        successRate: 1,
        status:
          duration >=
          DEGRADED_RPC_LATENCY_MS
            ? 'degraded'
            : 'healthy',
        blockHeight,
      };
    } catch (error) {
      const rpcError =
        error instanceof SuiRpcError
          ? error
          : null;

      return {
        endpoint,
        latency: [
          rpcError?.duration ??
            RPC_TIMEOUT_MS,
        ],
        successRate: 0,
        status:
          rpcError?.status === 504
            ? 'degraded'
            : 'down',
        blockHeight: 0,
      };
    }
  };

// ─── SuiNS resolution ────────────────────────────────────────────────────
// Sui RPC methods that take an "owner" expect a 0x-prefixed hex address.
// These helpers let callers pass either a raw address or a SuiNS name
// like `aliphatic.sui` and auto-resolve through `suix_resolveNameServiceAddress`.

const SUI_ADDRESS_RE = /^0x[0-9a-fA-F]{1,64}$/;
const SUI_NS_RE = /^[a-z0-9-]+(\.[a-z0-9-]+)*\.sui$/i;

export const looksLikeSuiAddress = (value: string): boolean =>
    SUI_ADDRESS_RE.test(value.trim());

export const looksLikeSuiNs = (value: string): boolean =>
    SUI_NS_RE.test(value.trim());

const SUI_NS_CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes

type SuiNsCacheEntry = { address: string; expiresAt: number };

const suiNsCache = new Map<string, SuiNsCacheEntry>();
const cacheKey = (network: Network, name: string) => `${network}:${name.trim().toLowerCase()}`;


/**
 * Resolve a Sui address or SuiNS name to a raw 0x address.
 * Returns the input unchanged if it already looks like an address.
 * Throws SuiRpcError if the name cannot be resolved.
 */
export const resolveSuiAddress = async (
    network: Network,
    input: string,
): Promise<string> => {
    const value = input.trim();
    if (looksLikeSuiAddress(value)) return value;
    if (!looksLikeSuiNs(value)) {
        // Pass through unchanged — let the underlying RPC reject if invalid.
        return value;
    }

    const key = cacheKey(network, value);
    const cached = suiNsCache.get(key);
    if (cached) {
        if (cached.expiresAt > Date.now()) {
            return cached.address;
        }

        suiNsCache.delete(key);
    }

    const { result } = await executeSuiRpc(network, 'suix_resolveNameServiceAddress', [value]);
    if (typeof result !== 'string' || !looksLikeSuiAddress(result)) {
        throw new SuiRpcError(`Could not resolve ${value}`, {
            status: 200,
            endpoint: getActiveSuiRpcUrl(network),
            duration: 0,
        });
    }

    suiNsCache.set(key, { address: result, expiresAt: Date.now() + SUI_NS_CACHE_TTL_MS });
    return result;
};

export const simulateMoveCall = async (
  network: Network,
  sender: string,
  packageId: string,
  module: string,
  func: string,
  typeArgs: string[],
  args: BuilderArg[]
) => {
    // Convert BuilderArgs to raw arguments for simulation/inspection
    // For simulation, we can often pass pure values as is, and object IDs as strings
    const rawArgs = args.map(arg => {
        if (arg.type === 'u64' || arg.type === 'u128' || arg.type === 'u256') {
            return arg.value; // Passed as string to avoid precision loss
        }
        if (arg.type === 'u8' || arg.type === 'u16' || arg.type === 'u32') {
            return parseInt(arg.value);
        }
        if (arg.type === 'bool') {
            return arg.value === 'true';
        }
        // Address, String, Object ID, etc.
        return arg.value;
    });

    const resolvedSender = await resolveSuiAddress(network, sender);

    const method = 'sui_devInspectTransactionBlock';
    const params = [
        resolvedSender,
        {
            kind: 'moveCall',
            target: `${packageId}::${module}::${func}`,
            typeArguments: typeArgs,
            arguments: rawArgs
        },
        null,
        null
    ];

    return executeSuiRpc(network, method, params);
};

export const getOwnedObjects = async (network: Network, address: string) => {
    const resolved = await resolveSuiAddress(network, address);
    return executeSuiRpc(network, 'suix_getOwnedObjects', [
        resolved,
        { options: { showType: true, showContent: true, showDisplay: true } }
    ]);
};

export const getObject = async (network: Network, objectId: string) => {
    return executeSuiRpc(network, 'sui_getObject', [
        objectId,
        { showType: true, showContent: true, showOwner: true }
    ]);
};

export const getBalance = async (network: Network, owner: string) => {
    const resolved = await resolveSuiAddress(network, owner);
    return executeSuiRpc(network, 'suix_getBalance', [
        resolved,
        '0x2::sui::SUI'
    ]);
};

export const signAndExecuteMoveCall = async (
  network: Network,
  sender: string,
  packageId: string,
  module: string,
  func: string,
  typeArgs: string[],
  args: BuilderArg[],
  signAndExecuteTransaction: (transactionBlock: any) => Promise<any>
) => {
    const resolvedSender = await resolveSuiAddress(network, sender);

    // Import Transaction dynamically to avoid circular dependencies
    const { Transaction } = await import('@mysten/sui/transactions');

    const txb = new Transaction();

    // Convert BuilderArgs into typed transaction arguments
    const txArgs = args.map(arg => {
        switch (arg.type) {
            case 'u8':
                return txb.pure.u8(parseInt(arg.value, 10));
            case 'u16':
                return txb.pure.u16(parseInt(arg.value, 10));
            case 'u32':
                return txb.pure.u32(parseInt(arg.value, 10));
            case 'u64':
                return txb.pure.u64(arg.value); // Passed as string to avoid precision loss
            case 'u128':
                return txb.pure.u128(arg.value);
            case 'u256':
                return txb.pure.u256(arg.value);
            case 'bool':
                return txb.pure.bool(arg.value === 'true');
            case 'address':
                return txb.pure.address(arg.value);
            case 'object':
                return txb.object(arg.value);
            case 'vector<u8>':
                return txb.pure.vector('u8', arg.value.split(',').map(v => parseInt(v.trim(), 10)));
            case 'vector<address>':
                return txb.pure.vector('address', arg.value.split(',').map(v => v.trim()));
            default:
                return txb.pure.string(arg.value);
        }
    });

    txb.moveCall({
        target: `${packageId}::${module}::${func}`,
        typeArguments: typeArgs,
        arguments: txArgs
    });

    try {
        const result = await signAndExecuteTransaction(txb);
        return {
            result: {
                digest: result.digest,
                transaction: result.transaction,
                effects: result.effects,
                confirmed: true,
                executed: true
            },
            duration: 0,
            status: 200
        };
    } catch (error: any) {
        throw new SuiRpcError(
            error instanceof Error && error.message.trim()
                ? error.message
                : 'Transaction signing or execution failed.',
            {
                status: 500,
                endpoint: getActiveSuiRpcUrl(network),
                duration: 0,
            }
        );
    }
};