use crate::app::{Cli, MathCommands, PairCommands, PositionCommands, SwapCli, TicksCommands};
use crate::command::fee_tier::fee_tier::process_fee_tier_info;
use crate::command::math::price::{process_sqrt_price_to_tick, process_tick_to_sqrt_price};
use crate::command::pair::accept_protocol_fee_authority::process_accept_protocol_fee_authority;
use crate::command::pair::collect_partner_fee::process_collect_partner_fee;
use crate::command::pair::collect_protocol_fee::process_collect_protocol_fee;
use crate::command::pair::config::process_config_info;
use crate::command::pair::create_fee_tier::{
    process_create_fee_tier, process_create_fee_tier_template,
};
use crate::command::pair::create_partner::{
    process_create_partner, process_create_partner_template,
};
use crate::command::pair::create_pool::{process_create_pool, process_create_pool_template};
use crate::command::pair::create_tick_array::{
    process_create_tick_array, process_create_tick_array_template,
};
use crate::command::pair::init_config::{process_init_config, process_init_config_template};
use crate::command::pair::initialize_rewarder::process_initialize_rewarder;
use crate::command::pair::pair::process_pair_info;
use crate::command::pair::pair_list::process_pair_list;
use crate::command::pair::partner::process_partner_info;
use crate::command::pair::swap::process_swap;
use crate::command::pair::swap_with_partner::process_swap_with_partner;
use crate::command::pair::transfer_protocol_fee_authority::process_transfer_protocol_fee_authority;
use crate::command::pair::update_config_protocol_fee_rate::process_update_config_protocol_fee_rate;
use crate::command::pair::update_fee_rate::process_update_fee_rate;
use crate::command::pair::update_partner::process_update_partner;
use crate::command::pair::update_rewarder_emission::process_update_rewarder_emission;
use crate::command::position::collect_fee::process_collect_fee;
use crate::command::position::collect_rewarder::process_collect_rewarder;
use crate::command::position::decrease_liquidity::process_decrease_liquidity;
use crate::command::position::increase_liquidity::process_increase_liquidity;
use crate::command::position::increase_liquidity_with_fixed_token::process_increase_liquidity_with_fixed_token;
use crate::command::position::open_position::process_open_position;
use crate::command::position::position_list::process_position_list;
use crate::command::position::process_position_info;
use crate::command::position::remove_position::process_remove_position;
use crate::command::ticks::array_index::process_array_index_info;
use crate::command::ticks::price::process_tick_price_info;
use crate::command::ticks::tick::process_tick_info;
use crate::command::ticks::tick_array::process_tick_array_info;
use crate::command::ticks::tick_map::process_tick_map_info;
use common::command::{CliConfig, ProcessResult};
use common::init::Matche;
use solana_client::rpc_client::RpcClient;

pub fn process_command(
    config: &mut CliConfig,
    rpc_client: RpcClient,
    app: Box<dyn Matche>,
) -> ProcessResult {
    let app = app.as_any().downcast_ref::<Cli>().unwrap();
    match &app.command {
        SwapCli::Pair { command } => match command {
            PairCommands::AcceptProtocolFeeAuthority { clmm_config } => {
                process_accept_protocol_fee_authority(&rpc_client, config, &clmm_config)
            }
            PairCommands::CollectPartnerFee { partner, clmmpool } => {
                process_collect_partner_fee(&rpc_client, config, &partner, &clmmpool)
            }
            PairCommands::CollectProtocolFee { clmmpool } => {
                process_collect_protocol_fee(&rpc_client, config, &clmmpool)
            }
            PairCommands::CreatePoolTemplate { output_file } => {
                process_create_pool_template(&output_file)
            }
            PairCommands::CreatePool { entry_file } => {
                process_create_pool(&rpc_client, config, entry_file)
            }
            PairCommands::PartnerCreateTemplate { output_file } => {
                process_create_partner_template(output_file)
            }
            PairCommands::PartnerCreate { entry_file } => {
                process_create_partner(&rpc_client, config, entry_file)
            }
            PairCommands::PartnerInfo { partner } => process_partner_info(&rpc_client, *partner),
            PairCommands::TickArrayCreateTemplate { output_file } => {
                process_create_tick_array_template(output_file)
            }
            PairCommands::TickArrayCreate { entry_file } => {
                process_create_tick_array(&rpc_client, config, entry_file)
            }
            PairCommands::Info { pair_key } => process_pair_info(&rpc_client, &pair_key),
            PairCommands::List {} => process_pair_list(&rpc_client),
            PairCommands::ConfigInitTemplate { output_file } => {
                process_init_config_template(output_file)
            }
            PairCommands::ConfigInit { entry_file } => {
                process_init_config(&rpc_client, config, entry_file)
            }
            PairCommands::ConfigInfo {} => process_config_info(&rpc_client),
            PairCommands::FeeTierCreateTemplate { output_file } => {
                process_create_fee_tier_template(output_file)
            }
            PairCommands::FeeTierCreate { entry_file } => {
                process_create_fee_tier(&rpc_client, config, entry_file)
            }
            PairCommands::FeeTierInfo { fee_tier } => process_fee_tier_info(&rpc_client, *fee_tier),
            PairCommands::ConfigProtocolFeeRateUpdate {
                clmm_config,
                new_protocol_fee_rate,
                create_pool_authority,
                claim_authority,
            } => process_update_config_protocol_fee_rate(
                &rpc_client,
                config,
                &clmm_config,
                new_protocol_fee_rate,
                create_pool_authority,
                claim_authority,
            ),
            PairCommands::FeeRateUpdate {
                new_fee_rate,
                clmmpool,
            } => process_update_fee_rate(&rpc_client, config, *new_fee_rate, &clmmpool),
            PairCommands::PartnerUpdate {
                partner,
                new_fee_rate,
                new_claim_authority,
            } => process_update_partner(
                &rpc_client,
                &config,
                &partner,
                &new_fee_rate,
                &new_claim_authority,
            ),
            PairCommands::Swap {
                clmmpool,
                a_to_b,
                by_amount_in,
                price_limit_tick,
                amount,
            } => process_swap(
                &rpc_client,
                config,
                &clmmpool,
                by_amount_in.unwrap_or(true),
                *price_limit_tick,
                a_to_b.unwrap_or(true),
                &amount,
                &0f64,
            ),
            PairCommands::SwapWithPartner {
                clmmpool,
                partner,
                amount,
                a_to_b,
                by_amount_in,
                price_limit_tick,
            } => process_swap_with_partner(
                &rpc_client,
                config,
                &clmmpool,
                &partner,
                by_amount_in.unwrap_or(true),
                *price_limit_tick,
                a_to_b.unwrap_or(true),
                &amount,
                &0f64,
            ),
            PairCommands::InitRewarder {
                clmmpool,
                rewarder_authority_file,
                rewarder_token_mint,
                rewarder_index,
                mint_wrapper,
                minter,
            } => process_initialize_rewarder(
                &rpc_client,
                config,
                *clmmpool,
                rewarder_authority_file,
                *rewarder_token_mint,
                *rewarder_index,
                *mint_wrapper,
                *minter,
            ),
            PairCommands::UpdateRewarderEmission {
                clmmpool,
                rewarder_authority_file,
                rewarder_index,
                emissions_per_day,
            } => process_update_rewarder_emission(
                &rpc_client,
                config,
                *clmmpool,
                rewarder_authority_file,
                *rewarder_index,
                *emissions_per_day,
            ),
            PairCommands::TransferProtocolFeeAuthority {
                clmm_config,
                new_authority,
            } => process_transfer_protocol_fee_authority(
                &rpc_client,
                config,
                &clmm_config,
                &new_authority,
            ),
        },

        SwapCli::Pos { command } => match command {
            PositionCommands::CollectRewarder {
                mint,
                rewarder_index,
            } => process_collect_rewarder(&rpc_client, config, *mint, *rewarder_index),
            PositionCommands::Increase {
                mint,
                amount_a,
                amount_b,
                slid,
            } => {
                process_increase_liquidity(&rpc_client, config, &mint, &amount_a, &amount_b, &slid)
            }
            PositionCommands::IncreaseWithFixedToken {
                mint,
                amount,
                slid,
                is_a_fixed,
            } => process_increase_liquidity_with_fixed_token(
                &rpc_client,
                config,
                &mint,
                *amount,
                &slid,
                is_a_fixed.unwrap_or(true),
            ),
            PositionCommands::Decrease {
                mint,
                amount_a,
                amount_b,
                liquidity,
                slid,
            } => process_decrease_liquidity(
                &rpc_client,
                config,
                &mint,
                &amount_a,
                &liquidity,
                &amount_b,
                &slid,
            ),
            PositionCommands::Open {
                clmmpool,
                tick_lower_index,
                tick_upper_index,
            } => process_open_position(
                &rpc_client,
                config,
                &clmmpool,
                &tick_lower_index,
                &tick_upper_index,
            ),
            PositionCommands::Remove { mint } => {
                process_remove_position(&rpc_client, config, &mint)
            }
            PositionCommands::Info { mint } => process_position_info(&rpc_client, &mint),
            PositionCommands::CollectFee { mint } => {
                process_collect_fee(&rpc_client, config, &mint)
            }
            PositionCommands::List { clmmpool, auth } => {
                process_position_list(&rpc_client, *clmmpool, *auth)
            }
        },

        SwapCli::Math { command } => match command {
            MathCommands::TickToSqrtPrice { tick } => process_tick_to_sqrt_price(*tick),
            MathCommands::SqrtPriceToTick { price } => process_sqrt_price_to_tick(*price),
        },

        SwapCli::Ticks { command } => match command {
            TicksCommands::Array {
                pool,
                tick_index,
                array_index,
            } => process_tick_array_info(&rpc_client, *tick_index, *array_index, &pool),
            TicksCommands::Tick { pool, tick_index } => {
                process_tick_info(&rpc_client, *tick_index, &pool)
            }
            TicksCommands::Map { pool, array_index } => {
                process_tick_map_info(&rpc_client, *array_index, &pool)
            }
            TicksCommands::Price { tick } => process_tick_price_info(&rpc_client, *tick),
            TicksCommands::Index { tick, tick_spacing } => {
                process_array_index_info(*tick, *tick_spacing)
            }
        },
    }
}