use crate::CONFIG_FILE;
use clap::{Parser, Subcommand};
use common::init::Matche;
use solana_program::pubkey::Pubkey;
use std::any::Any;

#[derive(Parser)]
#[clap(name = "aaa", author, version, about, long_about = None)]
#[clap(propagate_version = true)]
pub struct Cli {
    /// crema cli config, consistent with the solana cli config (default: $HOME/.config/solana/cli/config.yml)
    #[clap(long, short, global = true, takes_value = true,
    default_value_t = {
    if let Some(ref config_file) = * CONFIG_FILE {
    config_file.to_string()
    } else {
    String::new()
    }
    }
    )]
    pub config_file: String,
    /// owner key default from config file Keypair
    #[clap(long, short, global = true, takes_value = true)]
    pub owner: Option<String>,
    // config_file: String,
    // owner: String,
    #[clap(subcommand)]
    pub command: SwapCli,
}

impl Matche for Cli {
    fn as_any(&self) -> &dyn Any {
        self
    }
    fn get_config_file(&self) -> &str {
        self.config_file.as_str()
    }
    fn get_owner(&self) -> &str {
        let s = self.owner.as_ref();
        if s.is_some() {
            s.unwrap().as_str()
        } else {
            ""
        }
    }
}

#[derive(Subcommand)]
pub enum SwapCli {
    /// pair command
    Pair {
        #[clap(subcommand)]
        command: PairCommands,
    },
    /// position command
    Pos {
        #[clap(subcommand)]
        command: PositionCommands,
    },
    /// math command
    Math {
        #[clap(subcommand)]
        command: MathCommands,
    },
    /// ticks command
    Ticks {
        #[clap(subcommand)]
        command: TicksCommands,
    },
}

#[derive(Subcommand)]
pub enum PairCommands {
    /// recalled by the new `ClmmConfig` authority to accept the authority
    AcceptProtocolFeeAuthority {
        /// The clmm_config is the config of new_authority to accept
        clmm_config: Pubkey,
    },
    /// collect the partner fee from ata controlled by partner pda
    CollectPartnerFee {
        /// The partner key
        partner: Pubkey,
        /// The clmmpool key
        clmmpool: Pubkey,
    },
    /// protocol_fee_claim_authority to collect the fee earn by the clmmpool
    CollectProtocolFee {
        /// The clmmpool key
        clmmpool: Pubkey,
    },
    /// create a yaml template for the create-pool
    CreatePoolTemplate {
        /// The config file output path (default: ./clmmpool-template.yaml)
        output_file: String,
    },
    /// create a clmm_pool
    CreatePool {
        /// The config file entry path (default: ./clmmpool-template.yaml)
        entry_file: String,
    },
    /// get clmm_pool info
    Info {
        /// pool key
        pair_key: Pubkey,
    },
    /// get clmm_pool list
    List {},
    /// create a yaml template for the init-config
    ConfigInitTemplate {
        /// The config file output path (default: ./clmm-config-template.yaml)
        output_file: String,
    },
    /// init clmm_config
    ConfigInit {
        /// The config file entry path (default: ./clmm-config-template.yaml)
        entry_file: String,
    },
    /// get config_info
    ConfigInfo {},
    /// create a yaml template for the create-fee-tier
    FeeTierCreateTemplate {
        /// The config file output path (default: ./fee-tier-template.yaml)
        output_file: String,
    },
    /// create fee tier
    FeeTierCreate {
        /// The config file entry path (default: ./fee-tier-template.yaml)
        entry_file: String,
    },
    /// get fee_tier_info
    FeeTierInfo {
        /// The fee_tier key
        fee_tier: Pubkey,
    },
    /// create a yaml template for the create-partner
    PartnerCreateTemplate {
        /// The config file output path (default: ./partner-template.yaml)
        output_file: String,
    },
    /// create partner
    PartnerCreate {
        /// The config file entry path (default: ./partner-template.yaml)
        entry_file: String,
    },
    /// get partner_info
    PartnerInfo {
        /// The partner key
        partner: Pubkey,
    },
    /// create a yaml template for the create-tick-array
    TickArrayCreateTemplate {
        /// The config file output path (default: ./tick-array-template.yaml)
        output_file: String,
    },
    /// create tick array
    TickArrayCreate {
        /// The config file entry path (default: ./tick-array-template.yaml)
        entry_file: String,
    },
    /// protocol_fee_authority of the ClmmConfig to another new authority
    TransferProtocolFeeAuthority {
        /// The clmm_config to transfer to new_authority
        clmm_config: Pubkey,
        /// The new_authority will be the new authority of clmm_config
        new_authority: Pubkey,
    },
    /// update the protocol_fee_rate on ClmmConfig
    ConfigProtocolFeeRateUpdate {
        /// protocol_fee_authority is the authority to update protocol_fee_rate
        clmm_config: Pubkey,
        /// The new_protocol_fee_rate to update protocol config
        #[clap(long, short = 'f', takes_value = true)]
        new_protocol_fee_rate: Option<u16>,
        /// create_pool_authority. default key(11111111111111111111111111111111), everyone can create pool.
        #[clap(long, short = 'p', takes_value = true)]
        create_pool_authority: Option<Pubkey>,
        /// protocol_fee claim authority.
        #[clap(long, short = 'a', takes_value = true)]
        claim_authority: Option<Pubkey>,
    },
    /// update the fee_rate on the clmmpool
    FeeRateUpdate {
        /// The new_fee_rate to update clmmpool
        new_fee_rate: f64,
        /// The clmmpool to update the fee_rate
        clmmpool: Pubkey,
    },
    /// update partner fee_rate or claim authority
    PartnerUpdate {
        /// partner is the existed partner to update
        partner: Pubkey,
        /// The new fee rate to update partner
        new_fee_rate: Option<u16>,
        /// The new claim authority to update partner
        new_claim_authority: Option<Pubkey>,
    },

    /// swap
    Swap {
        /// The clmmpool
        clmmpool: Pubkey,
        /// swap amount
        amount: f64,
        /// swap direction, true: a->b, false: b->a
        #[clap(long, short = 'd', takes_value = true)]
        a_to_b: Option<bool>,
        /// swap by amount in, ture: in, false: out
        #[clap(long, short = 'i', global = true, takes_value = true)]
        by_amount_in: Option<bool>,
        /// swap price limit for tick
        #[clap(
            long,
            short,
            global = true,
            takes_value = true,
            allow_hyphen_values = true
        )]
        price_limit_tick: Option<i32>,
    },

    /// swap with partner
    SwapWithPartner {
        /// The clmmpool
        clmmpool: Pubkey,
        /// The partner
        partner: Pubkey,
        /// swap amount
        amount: f64,
        /// swap direction, true: a->b, false: b->a
        #[clap(long, short = 'd', takes_value = true)]
        a_to_b: Option<bool>,
        /// swap by amount in, ture: in, false: out
        #[clap(long, short = 'i', global = true, takes_value = true)]
        by_amount_in: Option<bool>,
        /// swap price limit for tick
        #[clap(
            long,
            short,
            global = true,
            takes_value = true,
            allow_hyphen_values = true
        )]
        price_limit_tick: Option<i32>,
    },

    /// initialize rewarder
    InitRewarder {
        /// The pool key
        clmmpool: Pubkey,
        /// The rewarder authority private file(clmm_config.protocol_authority)
        rewarder_authority_file: String,
        /// The rewarder token mint
        rewarder_token_mint: Pubkey,
        /// The rewarder index
        rewarder_index: u8,
        /// The mint wrapper
        mint_wrapper: Pubkey,
        /// The minter
        minter: Pubkey,
    },
    /// update rewarder emission
    UpdateRewarderEmission {
        /// The pool key
        clmmpool: Pubkey,
        /// The rewarder authority private file(clmm_config.protocol_authority)
        rewarder_authority_file: String,
        /// The rewarder index
        rewarder_index: u8,
        /// The emissions per day
        emissions_per_day: f64,
    },
}

#[derive(Subcommand)]
pub enum PositionCommands {
    /// collect rewarder
    CollectRewarder {
        /// provider the position mint address
        mint: Pubkey,
        /// rewarder index for position rewarders
        rewarder_index: u8,
    },
    /// open a new position
    Open {
        /// pool key
        clmmpool: Pubkey,
        /// tick lower index
        #[clap(allow_hyphen_values = true)]
        tick_lower_index: i32,
        /// tick upper index
        #[clap(allow_hyphen_values = true)]
        tick_upper_index: i32,
    },
    /// provider the position mint address
    Remove {
        /// remove a position
        mint: Pubkey,
    },
    /// decrease liquidity to position
    Decrease {
        /// provider the position mint key
        mint: Pubkey,
        #[clap(
            long,
            short = 'a',
            global = true,
            takes_value = true,
            default_value_t = 0.0
        )]
        /// The token amount a
        amount_a: f64,
        #[clap(
            long,
            short = 'b',
            global = true,
            takes_value = true,
            default_value_t = 0.0
        )]
        /// The token amount b
        amount_b: f64,
        #[clap(
            long,
            short = 'l',
            global = true,
            takes_value = true,
            default_value_t = 0
        )]
        /// The liquidity
        liquidity: u128,
        #[clap(
            long,
            short = 's',
            global = true,
            takes_value = true,
            default_value_t = 0.01
        )]
        /// The slid rate (default 0.01)
        slid: f64,
    },
    /// increase liquidity to position
    Increase {
        /// provider the position mint key
        mint: Pubkey,
        #[clap(
            long,
            short = 'a',
            global = true,
            takes_value = true,
            default_value_t = 0.0
        )]
        /// The token amount a
        amount_a: f64,
        #[clap(
            long,
            short = 'b',
            global = true,
            takes_value = true,
            default_value_t = 0.0
        )]
        /// The token amount b
        amount_b: f64,
        #[clap(
            long,
            short = 's',
            global = true,
            takes_value = true,
            default_value_t = 0.01
        )]
        /// The slid rate (default 0.01)
        slid: f64,
    },
    IncreaseWithFixedToken {
        mint: Pubkey,
        #[clap(
            long,
            short = 'a',
            global = true,
            takes_value = true,
            default_value_t = 0.0
        )]
        amount: f64,
        #[clap(
            long,
            short = 's',
            global = true,
            takes_value = true,
            default_value_t = 0.01
        )]
        slid: f64,
        #[clap(long, short = 'f', takes_value = true)]
        is_a_fixed: Option<bool>,
    },
    /// get position list
    List {
        /// The clmm pool key
        #[clap(long, short = 'p', global = true, takes_value = true)]
        clmmpool: Option<Pubkey>,
        #[clap(long, short = 'a', global = true, takes_value = true)]
        /// The user owner key
        auth: Option<Pubkey>,
    },
    /// get position info
    Info {
        /// provider the position mint address to retreive the position details
        mint: Pubkey,
    },
    /// position owner to collect the fee the position owned
    CollectFee {
        /// provider the position mint address
        mint: Pubkey,
    },
}

#[derive(Subcommand)]
pub enum MathCommands {
    /// tick to sqrt_price
    TickToSqrtPrice {
        #[clap(allow_hyphen_values = true)]
        tick: i32,
    },
    /// sqrt_price to tick
    SqrtPriceToTick { price: u128 },
}

#[derive(Subcommand)]
pub enum TicksCommands {
    /// retrive one tick info
    Tick {
        /// pool key
        pool: Pubkey,
        /// tick index
        #[clap(allow_hyphen_values = true)]
        tick_index: i32,
    },
    /// tick array info
    Array {
        /// pool key
        pool: Pubkey,
        #[clap(
            long,
            short,
            global = true,
            takes_value = true,
            allow_hyphen_values = true
        )]
        /// the tick array contains this tick index
        tick_index: Option<i32>,
        #[clap(long, short, global = true, takes_value = true)]
        /// array index
        array_index: Option<u16>,
    },
    /// tick array map info
    Map {
        /// pool key
        pool: Pubkey,
        /// array index
        array_index: u16,
    },
    /// tick to price
    Price {
        #[clap(allow_hyphen_values = true)]
        tick: i32,
    },
    /// given tick index, return array_index and tick range
    Index {
        /// tick index
        #[clap(allow_hyphen_values = true)]
        tick: i32,
        /// tick spacing
        tick_spacing: u16,
    },
}