use crate::coex::exchange_team::*;
use crate::coex::order_team::*;
use csv::{DeserializeRecordsIter, StringRecord};
use rust_decimal::prelude::ToPrimitive;
use rust_decimal::Decimal;
use serde::Deserialize;

// use super::strategy_test;
use super::{
    exists_record, insert_one_record, try_join_all, try_select_record, AllData, ExchangeInfo,
    FilteredDataValue, FromRow, HashMap, RealtimePriceData, TradeFee,
};
use crate::signal_association::signal_decision::*;
use tokio::time::{sleep, Duration, Instant};

#[derive(Debug, FromRow)]
struct ServerEpoch {
    server_epoch: u64,
}

#[derive(Debug, FromRow)]
struct Record {
    symbol: String,
    suggested_price: Decimal,
    close_time: u64,
    registered_server_epoch: u64,
    registerer: u16,
    is_long: u8,
}

pub async fn execute_list_up_for_buy(
    all_data: &AllData,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    // crate::strategy_team::strategy_001::list_up_for_buy(all_data).await;
    // crate::strategy_team::strategy_002::list_up_for_buy(all_data).await;
    // crate::strategy_team::strategy_003::list_up_for_buy(all_data).await;
    // crate::strategy_team::strategy_004::list_up_for_buy(all_data).await;
    // crate::strategy_team::strategy_005::list_up_for_buy(all_data).await;
    crate::strategy_team::strategy_006::list_up_for_buy(all_data).await;
    crate::strategy_team::strategy_007::list_up_for_buy(all_data).await;
    crate::strategy_team::strategy_008::list_up_for_buy(all_data).await;

    Ok(())
}

pub async fn execute_list_up_for_sell(
    all_data: &AllData,
    exchange_info_map: &HashMap<String, ExchangeInfo>,
    trade_fee_map: &HashMap<String, TradeFee>,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    // crate::strategy_team::strategy_001::list_up_for_sell(&all_data, &exchange_info_map, &trade_fee_map).await;
    // crate::strategy_team::strategy_002::list_up_for_sell(&all_data, &exchange_info_map, &trade_fee_map).await;
    // crate::strategy_team::strategy_003::list_up_for_sell(&all_data, &exchange_info_map, &trade_fee_map).await;
    // crate::strategy_team::strategy_004::list_up_for_sell(&all_data, &exchange_info_map, &trade_fee_map).await;
    // crate::strategy_team::strategy_005::list_up_for_sell(&all_data, &exchange_info_map, &trade_fee_map).await;
    crate::strategy_team::strategy_006::list_up_for_sell(
        &all_data,
        &exchange_info_map,
        &trade_fee_map,
    )
    .await;
    crate::strategy_team::strategy_007::list_up_for_sell(
        &all_data,
        &exchange_info_map,
        &trade_fee_map,
    )
    .await;
    crate::strategy_team::strategy_008::list_up_for_sell(
        &all_data,
        &exchange_info_map,
        &trade_fee_map,
    )
    .await;

    Ok(())
}

pub async fn insert_pre_suggested_coins(
    registerer: i32,
    is_long: bool,
    filtered_coins: &HashMap<String, FilteredDataValue>,
    alldata: &AllData,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    // Check the existance of record that is registered by this strategist
    let mut dest_table_name = String::from("suggested_coin_list");
    let mut dest2_table_name = String::from("buy_ordered_coin_list");
    let mut dest3_table_name = String::from("pre_suggested_coin_list");
    let mut insert_table_name = String::from("pre_suggested_coin_list");
    let mut exists_condition_build = String::from("registerer=");
    exists_condition_build.push_str(registerer.to_string().as_str());
    let mut exists_condition = Some(exists_condition_build);
    let exists_result1 = exists_record(&dest_table_name, &exists_condition).await;
    let exists_result2 = exists_record(&dest2_table_name, &exists_condition).await;
    let exists_result3 = exists_record(&dest3_table_name, &exists_condition).await;
    let insert_columns = vec![
        "symbol",
        "close_time",
        "suggested_price",
        "current_price",
        "stoploss",
        "target_price",
        "registered_server_epoch",
        "profit_percent",
        "minimum_profit_percent",
        "maximum_profit_percent",
        "registerer",
        "is_long",
    ];

    if exists_result1 == true && exists_result2 == true && exists_result3 == true {
        // Bring the current list of pre-suggested coins from [pre_suggested_coin_list] and [ordered_coin_list]
        #[derive(FromRow)]
        struct SelectData {
            symbol: String,
            close_time: i64,
        }
        #[derive(FromRow)]
        struct SelectData2 {
            symbol: String,
            close_time: i64,
        }
        let mut select_columns = String::from("symbol, close_time");
        let mut condition_build = String::from("WHERE registerer=");
        condition_build.push_str(registerer.to_string().as_str());
        let select_condition = Some(condition_build);
        let select_data_structure = SelectData {
            symbol: String::new(),
            close_time: 0,
        };
        let mut select_columns2 = String::from("symbol, close_time");
        let select_data_structure2 = SelectData2 {
            symbol: String::new(),
            close_time: 0,
        };
        let suggested_coin_list = try_select_record(
            &dest_table_name,
            &select_columns,
            &select_condition,
            &select_data_structure,
        )
        .await?;
        let ordered_coin_list = try_select_record(
            &dest2_table_name,
            &select_columns2,
            &select_condition,
            &select_data_structure2,
        )
        .await?;
        let pre_suggested_coin_list = try_select_record(
            &dest3_table_name,
            &select_columns,
            &select_condition,
            &select_data_structure,
        )
        .await?;

        // insert record without duplicate(registerer, closetime, symbol) into [pre_suggested_coin_list]
        for (symbol, filtered_data) in filtered_coins {
            let mut is_dupe = false; // initialize

            for list_element in &suggested_coin_list {
                if (*symbol == list_element.symbol)
                    && (filtered_data.closetime == list_element.close_time)
                {
                    is_dupe = true;
                    break;
                }
            }

            for list_element in &ordered_coin_list {
                if (*symbol == list_element.symbol)
                    && (filtered_data.closetime == list_element.close_time)
                {
                    is_dupe = true;
                    break;
                }
            }

            for list_element in &pre_suggested_coin_list {
                if (*symbol == list_element.symbol)
                    && (filtered_data.closetime == list_element.close_time)
                {
                    is_dupe = true;
                    break;
                }
            }

            if is_dupe == false {
                let mut insert_values = vec![
                    symbol.clone(),                          // symbol
                    filtered_data.closetime.to_string(),     // close_time
                    filtered_data.current_price.to_string(), // suggested_price
                    filtered_data.current_price.to_string(), // current_price
                    filtered_data.stoploss.to_string(),      // stoploss
                    filtered_data.target_price.to_string(),  // target_price
                    get_server_epoch().await.to_string(),    // registered_server_epoch
                    0.0.to_string(),                         // profit_percent
                    0.0.to_string(),                         // minimum_profit_percent
                    0.0.to_string(),                         // maximum_profit_percent
                    registerer.to_string(),                  // registerer
                ];

                if is_long == true {
                    insert_values.push(1.to_string()); // is_long
                } else {
                    insert_values.push(0.to_string()); // is_long
                }

                insert_one_record(&insert_table_name, &insert_columns, &insert_values).await;
            }
        }
    } else if exists_result1 == true && exists_result2 == true && exists_result3 == false {
        // Bring the current list of pre-suggested coins from [pre_suggested_coin_list] and [ordered_coin_list]
        #[derive(FromRow)]
        struct SelectData {
            symbol: String,
            close_time: i64,
        }
        #[derive(FromRow)]
        struct SelectData2 {
            symbol: String,
            close_time: i64,
        }
        let mut select_columns = String::from("symbol, close_time");
        let mut condition_build = String::from("WHERE registerer=");
        condition_build.push_str(registerer.to_string().as_str());
        let select_condition = Some(condition_build);
        let select_data_structure = SelectData {
            symbol: String::new(),
            close_time: 0,
        };
        let mut select_columns2 = String::from("symbol, close_time");
        let select_data_structure2 = SelectData2 {
            symbol: String::new(),
            close_time: 0,
        };
        let suggested_coin_list = try_select_record(
            &dest_table_name,
            &select_columns,
            &select_condition,
            &select_data_structure,
        )
        .await?;
        let ordered_coin_list = try_select_record(
            &dest2_table_name,
            &select_columns2,
            &select_condition,
            &select_data_structure2,
        )
        .await?;

        // insert record without duplicate(registerer, closetime, symbol) into [pre_suggested_coin_list]
        for (symbol, filtered_data) in filtered_coins {
            let mut is_dupe = false; // initialize

            for list_element in &suggested_coin_list {
                if (*symbol == list_element.symbol)
                    && (filtered_data.closetime == list_element.close_time)
                {
                    is_dupe = true;
                    break;
                }
            }

            for list_element in &ordered_coin_list {
                if (*symbol == list_element.symbol)
                    && (filtered_data.closetime == list_element.close_time)
                {
                    is_dupe = true;
                    break;
                }
            }

            if is_dupe == false {
                let mut insert_values = vec![
                    symbol.clone(),                          // symbol
                    filtered_data.closetime.to_string(),     // close_time
                    filtered_data.current_price.to_string(), // suggested_price
                    filtered_data.current_price.to_string(), // current_price
                    filtered_data.stoploss.to_string(),      // stoploss
                    filtered_data.target_price.to_string(),  // target_price
                    get_server_epoch().await.to_string(),    // registered_server_epoch
                    0.0.to_string(),                         // profit_percent
                    0.0.to_string(),                         // minimum_profit_percent
                    0.0.to_string(),                         // maximum_profit_percent
                    registerer.to_string(),                  // registerer
                ];

                if is_long == true {
                    insert_values.push(1.to_string()); // is_long
                } else {
                    insert_values.push(0.to_string()); // is_long
                }

                insert_one_record(&insert_table_name, &insert_columns, &insert_values).await;
            }
        }
    } else if exists_result1 == true && exists_result2 == false && exists_result3 == true {
        // Bring the current list of pre-suggested coins from [pre_suggested_coin_list] and [ordered_coin_list]
        #[derive(FromRow)]
        struct SelectData {
            symbol: String,
            close_time: i64,
        }
        let mut select_columns = String::from("symbol, close_time");
        let mut condition_build = String::from("WHERE registerer=");
        condition_build.push_str(registerer.to_string().as_str());
        let select_condition = Some(condition_build);
        let select_data_structure = SelectData {
            symbol: String::new(),
            close_time: 0,
        };
        let suggested_coin_list = try_select_record(
            &dest_table_name,
            &select_columns,
            &select_condition,
            &select_data_structure,
        )
        .await?;
        let pre_suggested_coin_list = try_select_record(
            &dest3_table_name,
            &select_columns,
            &select_condition,
            &select_data_structure,
        )
        .await?;

        // insert record without duplicate(registerer, closetime, symbol) into [pre_suggested_coin_list]
        for (symbol, filtered_data) in filtered_coins {
            let mut is_dupe = false; // initialize

            for list_element in &suggested_coin_list {
                if (*symbol == list_element.symbol)
                    && (filtered_data.closetime == list_element.close_time)
                {
                    is_dupe = true;
                    break;
                }
            }

            for list_element in &pre_suggested_coin_list {
                if (*symbol == list_element.symbol)
                    && (filtered_data.closetime == list_element.close_time)
                {
                    is_dupe = true;
                    break;
                }
            }

            if is_dupe == false {
                let mut insert_values = vec![
                    symbol.clone(),                          // symbol
                    filtered_data.closetime.to_string(),     // close_time
                    filtered_data.current_price.to_string(), // suggested_price
                    filtered_data.current_price.to_string(), // current_price
                    filtered_data.stoploss.to_string(),      // stoploss
                    filtered_data.target_price.to_string(),  // target_price
                    get_server_epoch().await.to_string(),    // registered_server_epoch
                    0.0.to_string(),                         // profit_percent
                    0.0.to_string(),                         // minimum_profit_percent
                    0.0.to_string(),                         // maximum_profit_percent
                    registerer.to_string(),                  // registerer
                ];

                if is_long == true {
                    insert_values.push(1.to_string()); // is_long
                } else {
                    insert_values.push(0.to_string()); // is_long
                }

                insert_one_record(&insert_table_name, &insert_columns, &insert_values).await;
            }
        }
    } else if exists_result1 == true && exists_result2 == false && exists_result3 == false {
        // Bring the current list of pre-suggested coins from [pre_suggested_coin_list] and [ordered_coin_list]
        #[derive(FromRow)]
        struct SelectData {
            symbol: String,
            close_time: i64,
        }
        let mut select_columns = String::from("symbol, close_time");
        let mut condition_build = String::from("WHERE registerer=");
        condition_build.push_str(registerer.to_string().as_str());
        let select_condition = Some(condition_build);
        let select_data_structure = SelectData {
            symbol: String::new(),
            close_time: 0,
        };
        let suggested_coin_list = try_select_record(
            &dest_table_name,
            &select_columns,
            &select_condition,
            &select_data_structure,
        )
        .await?;

        // insert record without duplicate(registerer, closetime, symbol) into [pre_suggested_coin_list]
        for (symbol, filtered_data) in filtered_coins {
            let mut is_dupe = false; // initialize

            for list_element in &suggested_coin_list {
                if (*symbol == list_element.symbol)
                    && (filtered_data.closetime == list_element.close_time)
                {
                    is_dupe = true;
                    break;
                }
            }

            if is_dupe == false {
                let mut insert_values = vec![
                    symbol.clone(),                          // symbol
                    filtered_data.closetime.to_string(),     // close_time
                    filtered_data.current_price.to_string(), // suggested_price
                    filtered_data.current_price.to_string(), // current_price
                    filtered_data.stoploss.to_string(),      // stoploss
                    filtered_data.target_price.to_string(),  // target_price
                    get_server_epoch().await.to_string(),    // registered_server_epoch
                    0.0.to_string(),                         // profit_percent
                    0.0.to_string(),                         // minimum_profit_percent
                    0.0.to_string(),                         // maximum_profit_percent
                    registerer.to_string(),                  // registerer
                ];

                if is_long == true {
                    insert_values.push(1.to_string()); // is_long
                } else {
                    insert_values.push(0.to_string()); // is_long
                }

                insert_one_record(&insert_table_name, &insert_columns, &insert_values).await;
            }
        }
    } else if exists_result1 == false && exists_result2 == true && exists_result3 == true {
        // Bring the current list of pre-suggested coins from [pre_suggested_coin_list] and [ordered_coin_list]
        #[derive(FromRow)]
        struct SelectData {
            symbol: String,
            close_time: i64,
        }
        #[derive(FromRow)]
        struct SelectData2 {
            symbol: String,
            close_time: i64,
        }
        let mut select_columns = String::from("symbol, close_time");
        let mut condition_build = String::from("WHERE registerer=");
        condition_build.push_str(registerer.to_string().as_str());
        let select_condition = Some(condition_build);
        let select_data_structure = SelectData {
            symbol: String::new(),
            close_time: 0,
        };
        let mut select_columns2 = String::from("symbol, close_time");
        let select_data_structure2 = SelectData2 {
            symbol: String::new(),
            close_time: 0,
        };
        let ordered_coin_list = try_select_record(
            &dest2_table_name,
            &select_columns2,
            &select_condition,
            &select_data_structure2,
        )
        .await?;
        let pre_suggested_coin_list = try_select_record(
            &dest3_table_name,
            &select_columns,
            &select_condition,
            &select_data_structure,
        )
        .await?;

        // insert record without duplicate(registerer, close_time, symbol) into [pre_suggested_coin_list]
        for (symbol, filtered_data) in filtered_coins {
            let mut is_dupe = false; // initialize

            for list_element in &ordered_coin_list {
                if (*symbol == list_element.symbol)
                    && (filtered_data.closetime == list_element.close_time)
                {
                    is_dupe = true;
                    break;
                }
            }

            for list_element in &pre_suggested_coin_list {
                if (*symbol == list_element.symbol)
                    && (filtered_data.closetime == list_element.close_time)
                {
                    is_dupe = true;
                    break;
                }
            }

            if is_dupe == false {
                let mut insert_values = vec![
                    symbol.clone(),                          // symbol
                    filtered_data.closetime.to_string(),     // close_time
                    filtered_data.current_price.to_string(), // suggested_price
                    filtered_data.current_price.to_string(), // current_price
                    filtered_data.stoploss.to_string(),      // stoploss
                    filtered_data.target_price.to_string(),  // target_price
                    get_server_epoch().await.to_string(),    // registered_server_epoch
                    0.0.to_string(),                         // profit_percent
                    0.0.to_string(),                         // minimum_profit_percent
                    0.0.to_string(),                         // maximum_profit_percent
                    registerer.to_string(),                  // registerer
                ];

                if is_long == true {
                    insert_values.push(1.to_string()); // is_long
                } else {
                    insert_values.push(0.to_string()); // is_long
                }

                insert_one_record(&insert_table_name, &insert_columns, &insert_values).await;
            }
        }
    } else if exists_result1 == false && exists_result2 == true && exists_result3 == false {
        // Bring the current list of pre-suggested coins from [pre_suggested_coin_list] and [ordered_coin_list]
        #[derive(FromRow)]
        struct SelectData {
            symbol: String,
            close_time: i64,
        }
        #[derive(FromRow)]
        struct SelectData2 {
            symbol: String,
            close_time: i64,
        }
        let mut select_columns = String::from("symbol, close_time");
        let mut condition_build = String::from("WHERE registerer=");
        condition_build.push_str(registerer.to_string().as_str());
        let select_condition = Some(condition_build);
        let select_data_structure = SelectData {
            symbol: String::new(),
            close_time: 0,
        };
        let mut select_columns2 = String::from("symbol, close_time");
        let select_data_structure2 = SelectData2 {
            symbol: String::new(),
            close_time: 0,
        };
        let ordered_coin_list = try_select_record(
            &dest2_table_name,
            &select_columns2,
            &select_condition,
            &select_data_structure2,
        )
        .await?;

        // insert record without duplicate(registerer, closetime, symbol) into [pre_suggested_coin_list]
        for (symbol, filtered_data) in filtered_coins {
            let mut is_dupe = false; // initialize

            for list_element in &ordered_coin_list {
                if (*symbol == list_element.symbol)
                    && (filtered_data.closetime == list_element.close_time)
                {
                    is_dupe = true;
                    break;
                }
            }

            if is_dupe == false {
                let mut insert_values = vec![
                    symbol.clone(),                          // symbol
                    filtered_data.closetime.to_string(),     // close_time
                    filtered_data.current_price.to_string(), // suggested_price
                    filtered_data.current_price.to_string(), // current_price
                    filtered_data.stoploss.to_string(),      // stoploss
                    filtered_data.target_price.to_string(),  // target_price
                    get_server_epoch().await.to_string(),    // registered_server_epoch
                    0.0.to_string(),                         // profit_percent
                    0.0.to_string(),                         // minimum_profit_percent
                    0.0.to_string(),                         // maximum_profit_percent
                    registerer.to_string(),                  // registerer
                ];

                if is_long == true {
                    insert_values.push(1.to_string()); // is_long
                } else {
                    insert_values.push(0.to_string()); // is_long
                }

                insert_one_record(&insert_table_name, &insert_columns, &insert_values).await;
            }
        }
    } else if exists_result1 == false && exists_result2 == false && exists_result3 == true {
        // Bring the current list of pre-suggested coins from [pre_suggested_coin_list] and [ordered_coin_list]
        #[derive(FromRow)]
        struct SelectData {
            symbol: String,
            close_time: i64,
        }
        let mut select_columns = String::from("symbol, close_time");
        let mut condition_build = String::from("WHERE registerer=");
        condition_build.push_str(registerer.to_string().as_str());
        let select_condition = Some(condition_build);
        let select_data_structure = SelectData {
            symbol: String::new(),
            close_time: 0,
        };
        let pre_suggested_coin_list = try_select_record(
            &dest3_table_name,
            &select_columns,
            &select_condition,
            &select_data_structure,
        )
        .await?;

        // insert record without duplicate(registerer, closetime, symbol) into [pre_suggested_coin_list]
        for (symbol, filtered_data) in filtered_coins {
            let mut is_dupe = false; // initialize

            for list_element in &pre_suggested_coin_list {
                if (*symbol == list_element.symbol)
                    && (filtered_data.closetime == list_element.close_time)
                {
                    is_dupe = true;
                    break;
                }
            }

            if is_dupe == false {
                let mut insert_values = vec![
                    symbol.clone(),                          // symbol
                    filtered_data.closetime.to_string(),     // close_time
                    filtered_data.current_price.to_string(), // suggested_price
                    filtered_data.current_price.to_string(), // current_price
                    filtered_data.stoploss.to_string(),      // stoploss
                    filtered_data.target_price.to_string(),  // target_price
                    get_server_epoch().await.to_string(),    // registered_server_epoch
                    0.0.to_string(),                         // profit_percent
                    0.0.to_string(),                         // minimum_profit_percent
                    0.0.to_string(),                         // maximum_profit_percent
                    registerer.to_string(),                  // registerer
                ];

                if is_long == true {
                    insert_values.push(1.to_string()); // is_long
                } else {
                    insert_values.push(0.to_string()); // is_long
                }

                insert_one_record(&insert_table_name, &insert_columns, &insert_values).await;
            }
        }
    } else {
        for (symbol, filtered_data) in filtered_coins {
            let mut insert_values = vec![
                symbol.clone(),                          // symbol
                filtered_data.closetime.to_string(),     // close_time
                filtered_data.current_price.to_string(), // suggested_price
                filtered_data.current_price.to_string(), // current_price
                filtered_data.stoploss.to_string(),      // stoploss
                filtered_data.target_price.to_string(),  // target_price
                get_server_epoch().await.to_string(),    // registered_server_epoch
                0.0.to_string(),                         // profit_percent
                0.0.to_string(),                         // minimum_profit_percent
                0.0.to_string(),                         // maximum_profit_percent
                registerer.to_string(),                  // registerer
            ];

            if is_long == true {
                insert_values.push(1.to_string()); // is_long
            } else {
                insert_values.push(0.to_string()); // is_long
            }

            insert_one_record(&insert_table_name, &insert_columns, &insert_values).await;
        }
    }

    Ok(())
}