import BN from 'bn.js';
import { array, publicKey, str, struct, u128, u16, u64, u8 } from '@coral-xyz/borsh';
import { AddressLookupTableAccount, PublicKey } from '@solana/web3.js';

import { Fraction, FractionLayout } from './fraction';
import { OracleAggregator, OracleAggregatorLayout } from './oracle';
import { OraclePrice } from '../states/oracles/oracle';
import Decimal from 'decimal.js';
import { BasketSettings, BasketSettingsLayout } from './config';
import { MAX_MANAGERS_PER_BASKET, MAX_SUPPORTED_TOKENS_PER_BASKET } from '../constants';
import { EditAddTokenSettings, EditAutomationSettings, EditCreatorSettings, EditCustomRebalanceSettings, EditDepositsSettings, EditFeeSettings, EditForceRebalanceSettings, EditLpSettings, EditMakeDirectSwapSettings, EditManagerSettings, EditMetadataSettings, EditScheduleSettings, EditUpdateWeightsSettings, OracleInput } from './intents/intent';

export type FormattedBasketType = "private" | "public";
export const BASKET_TYPES_STRINGS: Map<number, FormattedBasketType> = new Map([
    [0, "private"],
    [1, "public"],
]);

export interface FormattedAccumulatedFees {
    symmetry_fees: number;
    creator_fees: number;
    host_fees: number;
    managers_fees: number;
}

export interface FormattedLookupTables {
    active: {
        pubkey: string;
        contents: string[];
    }[];
    temp: {
        pubkey: string;
        contents: string[];
    }[];
}

export interface FormattedOracleSettings extends OracleInput {
    quote: string;
    side: string;
}

export interface FormattedOracle {
    oracle_settings: FormattedOracleSettings;
    accounts_to_load_lut_ids: number[];
    accounts_to_load_lut_indices: number[];
}

export interface FormattedOracleAggregator {
    num_oracles: number;
    min_oracles_thresh: number;
    oracles: FormattedOracle[];
    min_conf_bps: number,
    conf_thresh_bps: number,
    conf_multiplier: number,
}

export interface FormattedAsset {
    mint: string;
    amount: number;
    weight: number;
    active: boolean;
    oracle_aggregator: FormattedOracleAggregator;
}

export interface FormattedCreatorSettings extends EditCreatorSettings {}
export interface FormattedManagersSettings extends EditManagerSettings { updated_at: number; }
export interface FormattedFeeSettings extends EditFeeSettings {
    host_deposit_fee_bps: number;
    host_withdraw_fee_bps: number;
    host_management_fee_bps: number;
    host_performance_fee_bps: number;
    updated_at: number;
}
export interface FormattedScheduleSettings extends EditScheduleSettings { updated_at: number; }
export interface FormattedAutomationSettings extends EditAutomationSettings { updated_at: number; }
export interface FormattedLpSettings extends EditLpSettings { updated_at: number; }
export interface FormattedMetadataSettings extends EditMetadataSettings { updated_at: number; }
export interface FormattedDepositsSettings extends EditDepositsSettings {}
export interface FormattedForceRebalanceSettings extends EditForceRebalanceSettings { updated_at: number; }
export interface FormattedCustomRebalanceSettings extends EditCustomRebalanceSettings { updated_at: number; }
export interface FormattedAddTokenSettings extends EditAddTokenSettings { updated_at: number; }
export interface FormattedUpdateWeightsSettings extends EditUpdateWeightsSettings { updated_at: number; }
export interface FormattedMakeDirectSwapSettings extends EditMakeDirectSwapSettings { updated_at: number; }

export interface FormattedBasket {
    pubkey: string;
    name: string;
    symbol: string;
    uri: string;
    version: number;
    own_address: string;
    mint: string;
    supply_outstanding: number;
    creator: string;
    host: string;
    basket_type: FormattedBasketType;
    bounty_mint: string;
    bounty_balance: number;
    start_price: number;
    high_watermark: number;
    active_rebalance: number;
    active_withdraws: number;
    active_managements: number;
    last_automation_execution_timestamp: number;
    creator_settings: FormattedCreatorSettings;
    manager_settings: FormattedManagersSettings;
    fee_settings: FormattedFeeSettings;
    schedule_settings: FormattedScheduleSettings;
    automation_settings: FormattedAutomationSettings;
    lp_settings: FormattedLpSettings;
    metadata_settings: FormattedMetadataSettings;
    deposits_settings: FormattedDepositsSettings;
    force_rebalance_settings: FormattedForceRebalanceSettings;
    custom_rebalance_settings: FormattedCustomRebalanceSettings;
    add_token_settings: FormattedAddTokenSettings;
    update_weights_settings: FormattedUpdateWeightsSettings;
    make_direct_swap_settings: FormattedMakeDirectSwapSettings;
    accumulated_fees: FormattedAccumulatedFees;
    lookup_tables: FormattedLookupTables;
    composition: FormattedAsset[];
}

export interface BasketFees {
    symmetryFees: BN; // u64
    creatorFees: BN; // u64
    hostFees: BN; // u64
    managersFees: BN; // u64
};

export const BasketFeesLayout = struct<BasketFees>([
    u64("symmetryFees"),
    u64("creatorFees"),
    u64("hostFees"),
    u64("managersFees"),
]);

export interface FormattedWithdrawBasketFees {
    pubkey: string;
    basket: string;
    rent_payer: string;
    owners: string[];
    owners_weights: number[];
    accumulated_tokens: string[];
    accumulated_fees: number[];
}
export interface WithdrawBasketFees {
    basket: PublicKey;
    rentPayer: PublicKey;
    owners: PublicKey[]; // MAX_MANAGERS_PER_BASKET
    ownersWeights: number[]; // MAX_MANAGERS_PER_BASKET, u16
    accumulatedTokens: PublicKey[]; // MAX_SUPPORTED_TOKENS_PER_BASKET
    accumulatedFees: BN[]; // MAX_SUPPORTED_TOKENS_PER_BASKET, u64
    ownAddress?: PublicKey;
    formatted?: FormattedWithdrawBasketFees;
}

export const WithdrawBasketFeesLayout = struct<WithdrawBasketFees>([
    publicKey('basket'),
    publicKey('rentPayer'),
    array(publicKey(), MAX_MANAGERS_PER_BASKET, 'owners'),
    array(u16(), MAX_MANAGERS_PER_BASKET, 'ownersWeights'),
    array(publicKey(), MAX_SUPPORTED_TOKENS_PER_BASKET, 'accumulatedTokens'),
    array(u64(), MAX_SUPPORTED_TOKENS_PER_BASKET, 'accumulatedFees'),
]);

export interface LookupTables {
    active: PublicKey[]; // length 2
    temp: PublicKey[]; // length 2
};

export const LookupTablesLayout = struct<LookupTables>([
    array(publicKey(), 2, "active"),
    array(publicKey(), 2, "temp"),
]);

export interface Asset {
    mint: PublicKey;
    amount: BN; // u64
    weight: number; // u16
    active: number; // u8
    oracleAggregator: OracleAggregator;
    price?: OraclePrice;
    value?: Decimal;
};

export const AssetLayout = struct<Asset>([
    publicKey('mint'),
    u64('amount'),
    u16('weight'),
    u8('active'),
    OracleAggregatorLayout.replicate('oracleAggregator'),
]);

export interface Metadata {
    symbol: string,
    name: string,
    uri: string
}   

export interface Basket {
    version: number; // u8

    ownAddress: PublicKey;
    mint: PublicKey;
    supplyOutstanding: BN; // u64

    settings: BasketSettings;

    accumulatedFees: BasketFees;
    lookupTables: LookupTables;

    numTokens: number; // u8
    composition: Asset[]; // length MAX_SUPPORTED_TOKENS_PER_BASKET

    lutPubkeys?: AddressLookupTableAccount[];
    metadata?: Metadata;
    tvl?: Decimal;
    price?: Decimal;
    formatted?: FormattedBasket;
};

export const BasketLayout = struct<Basket>([
    u8('version'),
    publicKey('ownAddress'),
    publicKey('mint'),
    u64('supplyOutstanding'),
    BasketSettingsLayout.replicate('settings'),
    BasketFeesLayout.replicate('accumulatedFees'),
    LookupTablesLayout.replicate('lookupTables'),
    u8('numTokens'),
    array(AssetLayout, MAX_SUPPORTED_TOKENS_PER_BASKET, 'composition'),
]);