import { Contract } from "ethers";

/**
 * Position interface for swap calculations
 */
export interface Position {
  lowerTick: number;
  upperTick: number;
  weight: number;
}

/**
 * Vault positions structure
 */
export interface VaultPositions {
  multiPositions: {
    upperTick: number;
    lowerTick: number;
    relativeWeight: 1;
  }[];
  singlePosition: {
    upperTick: number;
    lowerTick: number;
  } | null;
}

/**
 * PositionExtractor extracts position data from vaults and execution results
 * 
 * Handles both multi-position and single-position vault types
 */
export class PositionExtractor {
  /**
   * Get current positions from a vault contract
   * 
   * @param vaultContract - The vault contract instance
   * @param isMultiPosition - Whether the vault supports multiple positions
   * @returns Promise<VaultPositions> - Current vault positions
   */
  async getCurrentVaultPositions(
    vaultContract: Contract,
    isMultiPosition: boolean
  ): Promise<VaultPositions> {
    let vaultCurrentMultiPositions: {
      upperTick: number;
      lowerTick: number;
      relativeWeight: 1;
    }[] = [];
    let vaultCurrentSinglePosition: {
      upperTick: number;
      lowerTick: number;
    } | null = null;

    if (isMultiPosition) {
      // Multi-position vaults use getPositions()
      vaultCurrentMultiPositions = await vaultContract.getPositions();
    } else {
      // Single-position vaults use upperTick() and lowerTick()
      const vaultUpperTick = await vaultContract.upperTick();
      const vaultLowerTick = await vaultContract.lowerTick();
      vaultCurrentSinglePosition = {
        upperTick: vaultUpperTick,
        lowerTick: vaultLowerTick,
      };
    }

    return {
      multiPositions: vaultCurrentMultiPositions,
      singlePosition: vaultCurrentSinglePosition,
    };
  }

  /**
   * Extract new positions from execution result
   * 
   * Parses executionResult.valuesArray[1] to extract position data:
   * - valuesArray[1][0] = lowerTicks array
   * - valuesArray[1][1] = upperTicks array
   * - valuesArray[1][2] = weights array
   * 
   * @param executionResult - The execution result from strategy execution
   * @returns Position[] - Array of extracted positions
   * @throws Error if extraction fails
   */
  extractNewPositions(executionResult: any): Position[] {
    const newPositions: Position[] = [];

    try {
      // Extract positions from valuesArray[1]
      // Format: [lowerTicks[], upperTicks[], weights[]]
      const positionData = executionResult.valuesArray[1];
      const lowerTicks = positionData[0];
      const upperTicks = positionData[1];
      const weights = positionData[2];

      for (let i = 0; i < lowerTicks.length; i++) {
        const position: Position = {
          lowerTick: Number(lowerTicks[i]),
          upperTick: Number(upperTicks[i]),
          weight: Number(weights[i]),
        };

        newPositions.push(position);
      }

      return newPositions;
    } catch (error) {
      const errorMessage = error instanceof Error ? error.message : String(error);
      throw new Error(`Failed to extract new positions: ${errorMessage}`);
    }
  }
}