use common::command::{CliConfig, ProcessResult};
use common::init::Matche;
use solana_client::rpc_client::RpcClient;
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::init_config::{process_init_config, process_init_config_template};
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::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::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_protocol_fee_rate::process_update_protocol_fee_rate;
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;

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 { config_key } => process_config_info(&rpc_client, *config_key),
                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,
                } => process_update_config_protocol_fee_rate(
                    &rpc_client,
                    config,
                    &clmm_config,
                    &new_protocol_fee_rate,
                ),
                PairCommands::FeeRateUpdate { fee_tier, clmmpool } => {
                    process_update_fee_rate(&rpc_client, config, &fee_tier, &clmmpool)
                }
                PairCommands::PartnerUpdate {
                    partner,
                    new_fee_rate,
                    new_claim_authority,
                } => process_update_partner(
                    &rpc_client,
                    &config,
                    &partner,
                    &new_fee_rate,
                    &new_claim_authority,
                ),
                PairCommands::ProtocolFeeRateUpdate { clmmpool } => {
                    process_update_protocol_fee_rate(&rpc_client, config, &clmmpool)
                }
                PairCommands::Swap {
                    clmmpool,
                    a_to_b,
                    by_amount_in,
                    price_limit_tick,
                    amount,
                } => process_swap(
                    &rpc_client,
                    config,
                    &clmmpool,
                    *by_amount_in,
                    *price_limit_tick,
                    *a_to_b,
                    &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,
                ),
                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),
            }
        }
    }
}