#![allow(unused)]
#![allow(warnings)]

use crate::coin_health_check_team::*;
use crate::request_candles::CandleData;
use crate::request_others::{CoinPriceData, ExchangeInfo, TradeFee};
use crate::server_health_check_team::ServerHealth;
use crate::strategy_team::AllData;
use crate::time_checking_team::UserTime;
use crate::value_estimation_team::datapoints::price_data::RealtimePriceData;
use reqwest::{Client, ClientBuilder};
use sqlx::{mysql::*, Connection, Executor, FromRow, Row};
use std::{
    io::{self, Write},
    sync::Arc,
};
use tokio::{fs::*, join, sync::mpsc, sync::watch, sync::Mutex, task::*, time::*};
use tradingbot::{RunningMode::*, *};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    initialization::initialization().await;

    // // let c1 = vec!(("name", "Shima Nabil"));
    // // println!("{:?}", database_control::update_record(&table_name, &c1, &("grade", "3")).await);

    // //database_control::exists_table(&table_name).await;
    // // let table_name = String::from("all24hstatistics");
    // // let result = database_control::count_rows(&table_name).await;
    // // println!("{:?}", result);

    // // let rows = sqlx::query("select * from serverhealth")
    // //     .map(|r| {
    // //         a.id = r.get::<i32, _>("id");
    // //         a.waiting_maximum = r.get::<i32, _>("waiting_maximum");
    // //         a.server_on = r.get::<bool, _>("server_on");
    // //         a.ping_on = r.get::<bool, _>("ping_on");
    // //         a.wallet_system_on = r.get::<bool, _>("wallet_system_on");
    // //
    // // })
    // //     .collect::<Vec<String>>()
    // //     .fetch(&pool).await;

    // // let str_result = rows
    // //     .iter()
    // //     .map(|r| format!("{} {}", r.get::<i32, _>("id"), r.get::<bool, _>("server_on")))
    // //     .collect::<Vec<String>>()
    // //     .join(", ");
    // // println!("{:?}", rows);
    // //

    let (tx_task1, mut rx_task0) = mpsc::unbounded_channel::<u32>();
    let tx_task2 = tx_task1.clone(); // for Task#2
    let tx_task3 = tx_task1.clone(); // for Task#3
    let tx_task4 = tx_task1.clone(); // for Task#4
    let tx_task5 = tx_task1.clone(); // for Task#5
    let tx_task6 = tx_task1.clone(); // for Task#6
    let tx_task7 = tx_task1.clone(); // for Task#7
    let tx_task8 = tx_task1.clone(); // for Task#8
    let tx_task9 = tx_task1.clone(); // for Task#9
    let tx_task10 = tx_task1.clone(); // for Task#10
    let tx_task11 = tx_task1.clone(); // for Task#11
    let tx_task12 = tx_task1.clone(); // for Task#12
    let tx_task13 = tx_task1.clone(); // for Task#13
    let tx_task14 = tx_task1.clone(); // for Task#14
    let tx_task15 = tx_task1.clone(); // for Task#15
    let tx_task16 = tx_task1.clone(); // for Task#16
    let tx_task17 = tx_task1.clone(); // for Task#17
    let tx_task18 = tx_task1.clone(); // for Task#18
    let tx_task19 = tx_task1.clone(); // for Task#19
    let tx_task20 = tx_task1.clone(); // for Task#20
    let tx_task21 = tx_task1.clone(); // for Task#21
    let tx_task22 = tx_task1.clone(); // for Task#22
    let tx_task23 = tx_task1.clone(); // for Task#23
    let tx_task24 = tx_task1.clone(); // for Task#24
    let tx_task25 = tx_task1.clone(); // for Task#25
    let tx_task26 = tx_task1.clone(); // for Task#26

    let (tx1, mut rx1_1) = watch::channel(0); //  local_epoch
    let mut rx1_2 = rx1_1.clone();
    let mut rx1_3 = rx1_1.clone();
    let mut rx1_4 = rx1_1.clone();
    let mut rx1_5 = rx1_1.clone();
    let mut rx1_6 = rx1_1.clone();
    let mut rx1_7 = rx1_1.clone();
    let (tx2, mut rx2) = watch::channel(0); // epoch_difference

    // trade fee data
    let mut tradefee_vec: Vec<TradeFee> = Vec::new(); // (symbol, makerCommission, takerCommission)
    let (tx_tradefee_vec, mut rx_tradefee_vec) = watch::channel(tradefee_vec);
    let mut rx2_tradefee_vec = rx_tradefee_vec.clone();
    let mut rx3_tradefee_vec = rx_tradefee_vec.clone();
    let mut rx4_tradefee_vec = rx_tradefee_vec.clone();
    let mut rx5_tradefee_vec = rx_tradefee_vec.clone();

    // valid usdt trade data
    let mut valid_usdt_trade_vec: Vec<String> = Vec::new(); // symbol
    let (tx_valid_usdt_trade_vec, mut rx_valid_usdt_trade_vec) =
        watch::channel(valid_usdt_trade_vec);
    let mut rx2_valid_usdt_trade_vec = rx_valid_usdt_trade_vec.clone();
    let mut rx3_valid_usdt_trade_vec = rx_valid_usdt_trade_vec.clone();
    let mut rx4_valid_usdt_trade_vec = rx_valid_usdt_trade_vec.clone();

    // price per second data and channels
    let mut price_vec: Vec<CoinPriceData> = Vec::new(); // (symbol, price)
    let (tx_price_vec, mut rx_price_vec) = watch::channel(price_vec);
    let mut rx3_price_vec = rx_price_vec.clone();
    let mut rx5_price_vec = rx_price_vec.clone();

    // candle data from endpoint and channels
    let mut candle_1m_vec: Vec<(String, Vec<CandleData>)> = Vec::new(); // (symbol, Vec<CandleData)>
    let (tx_candle_1m_vec, mut rx_candle_1m_vec) = watch::channel(candle_1m_vec);

    let mut candle_30m_vec: Vec<(String, Vec<CandleData>)> = Vec::new();
    let (tx_candle_30m_vec, mut rx_candle_30m_vec) = watch::channel(candle_30m_vec);

    let mut candle_1d_vec: Vec<(String, Vec<CandleData>)> = Vec::new();
    let (tx_candle_1d_vec, mut rx_candle_1d_vec) = watch::channel(candle_1d_vec);

    let mut candle_1w_vec: Vec<(String, Vec<CandleData>)> = Vec::new();
    let (tx_candle_1w_vec, mut rx_candle_1w_vec) = watch::channel(candle_1w_vec);

    let mut candle_1mon_vec: Vec<(String, Vec<CandleData>)> = Vec::new();
    let (tx_candle_1mon_vec, mut rx_candle_1mon_vec) = watch::channel(candle_1mon_vec);

    // real-time reflected price data and channels
    let mut rt_price_1m_vec: Vec<(String, Vec<RealtimePriceData>)> = Vec::new(); // (symbol, Vec<RealtimePriceData)>
    let (tx_rt_price_1m_vec, mut rx_rt_price_1m_vec) = watch::channel(rt_price_1m_vec);
    let mut rx2_rt_price_1m_vec = rx_rt_price_1m_vec.clone();
    let mut rx3_rt_price_1m_vec = rx_rt_price_1m_vec.clone();
    let mut rx4_rt_price_1m_vec = rx_rt_price_1m_vec.clone();
    let mut rx5_rt_price_1m_vec = rx_rt_price_1m_vec.clone();

    let mut rt_price_30m_vec: Vec<(String, Vec<RealtimePriceData>)> = Vec::new();
    let (tx_rt_price_30m_vec, mut rx_rt_price_30m_vec) = watch::channel(rt_price_30m_vec);
    let mut rx2_rt_price_30m_vec = rx_rt_price_30m_vec.clone();
    let mut rx3_rt_price_30m_vec = rx_rt_price_30m_vec.clone();
    let mut rx4_rt_price_30m_vec = rx_rt_price_30m_vec.clone();
    let mut rx5_rt_price_30m_vec = rx_rt_price_30m_vec.clone();

    let mut rt_price_1d_vec: Vec<(String, Vec<RealtimePriceData>)> = Vec::new();
    let (tx_rt_price_1d_vec, mut rx_rt_price_1d_vec) = watch::channel(rt_price_1d_vec);
    let mut rx2_rt_price_1d_vec = rx_rt_price_1d_vec.clone();
    let mut rx3_rt_price_1d_vec = rx_rt_price_1d_vec.clone();
    let mut rx4_rt_price_1d_vec = rx_rt_price_1d_vec.clone();

    let mut rt_price_1w_vec: Vec<(String, Vec<RealtimePriceData>)> = Vec::new();
    let (tx_rt_price_1w_vec, mut rx_rt_price_1w_vec) = watch::channel(rt_price_1w_vec);
    let mut rx2_rt_price_1w_vec = rx_rt_price_1w_vec.clone();
    let mut rx3_rt_price_1w_vec = rx_rt_price_1w_vec.clone();
    let mut rx4_rt_price_1w_vec = rx_rt_price_1w_vec.clone();

    let mut rt_price_1mon_vec: Vec<(String, Vec<RealtimePriceData>)> = Vec::new();
    let (tx_rt_price_1mon_vec, mut rx_rt_price_1mon_vec) = watch::channel(rt_price_1mon_vec);
    let mut rx2_rt_price_1mon_vec = rx_rt_price_1mon_vec.clone();
    let mut rx3_rt_price_1mon_vec = rx_rt_price_1mon_vec.clone();
    let mut rx4_rt_price_1mon_vec = rx_rt_price_1mon_vec.clone();

    // TEMA data
    // let mut tema3_1m_data: Vec<(String, Vec<(f64, i64)>)> = Vec::new();    // Vec<(symbol, Vec<(price, closetime)>)>
    // let (tx_tema3_1m_data, mut rx_tema3_1m_data) = watch::channel(tema3_1m_data);
    // let mut tema3_30m_data: Vec<(String, Vec<(f64, i64)>)> = Vec::new();
    // let (tx_tema3_30m_data, mut rx_tema3_30m_data) = watch::channel(tema3_30m_data);
    // let mut tema3_1d_data: Vec<(String, Vec<(f64, i64)>)> = Vec::new();
    // let (tx_tema3_1d_data, mut rx_tema3_1d_data) = watch::channel(tema3_1d_data);
    // let mut tema3_1w_data: Vec<(String, Vec<(f64, i64)>)> = Vec::new();
    // let (tx_tema3_1w_data, mut rx_tema3_1w_data) = watch::channel(tema3_1w_data);
    // let mut tema3_1mon_data: Vec<(String, Vec<(f64, i64)>)> = Vec::new();
    // let (tx_tema3_1mon_data, mut rx_tema3_1mon_data) = watch::channel(tema3_1mon_data);

    // let mut tema10_1m_data: Vec<(String, Vec<(f64, i64)>)> = Vec::new();    // Vec<(symbol, Vec<(price, closetime)>)>
    // let (tx_tema10_1m_data, mut rx_tema10_1m_data) = watch::channel(tema10_1m_data);
    // let mut tema10_30m_data: Vec<(String, Vec<(f64, i64)>)> = Vec::new();
    // let (tx_tema10_30m_data, mut rx_tema10_30m_data) = watch::channel(tema10_30m_data);
    // let mut tema10_1d_data: Vec<(String, Vec<(f64, i64)>)> = Vec::new();
    // let (tx_tema10_1d_data, mut rx_tema10_1d_data) = watch::channel(tema10_1d_data);
    // let mut tema10_1w_data: Vec<(String, Vec<(f64, i64)>)> = Vec::new();
    // let (tx_tema10_1w_data, mut rx_tema10_1w_data) = watch::channel(tema10_1w_data);
    // let mut tema10_1mon_data: Vec<(String, Vec<(f64, i64)>)> = Vec::new();
    // let (tx_tema10_1mon_data, mut rx_tema10_1mon_data) = watch::channel(tema10_1mon_data);

    // let mut tema30_1m_data: Vec<(String, Vec<(f64, i64)>)> = Vec::new();    // Vec<(symbol, Vec<(price, closetime)>)>
    // let (tx_tema30_1m_data, mut rx_tema30_1m_data) = watch::channel(tema30_1m_data);
    // let mut tema30_30m_data: Vec<(String, Vec<(f64, i64)>)> = Vec::new();
    // let (tx_tema30_30m_data, mut rx_tema30_30m_data) = watch::channel(tema30_30m_data);
    // let mut tema30_1d_data: Vec<(String, Vec<(f64, i64)>)> = Vec::new();
    // let (tx_tema30_1d_data, mut rx_tema30_1d_data) = watch::channel(tema30_1d_data);
    // let mut tema30_1w_data: Vec<(String, Vec<(f64, i64)>)> = Vec::new();
    // let (tx_tema30_1w_data, mut rx_tema30_1w_data) = watch::channel(tema30_1w_data);
    // let mut tema30_1mon_data: Vec<(String, Vec<(f64, i64)>)> = Vec::new();
    // let (tx_tema30_1mon_data, mut rx_tema30_1mon_data) = watch::channel(tema30_1mon_data);

    // Exchange Information data
    let mut exchange_info_data: Vec<ExchangeInfo> = Vec::new();
    let (tx_exchange_info_data, mut rx_exchange_info_data) = watch::channel(exchange_info_data);
    let mut rx2_exchange_info_data = rx_exchange_info_data.clone();
    let mut rx3_exchange_info_data = rx_exchange_info_data.clone();
    let mut rx4_exchange_info_data = rx_exchange_info_data.clone();
    let mut rx5_exchange_info_data = rx_exchange_info_data.clone();
    let mut rx6_exchange_info_data = rx_exchange_info_data.clone();

    {
        if RUNNING_MODE == RunningMode::REAL {
            println!("*** REAL MODE ***");
        } else if RUNNING_MODE == RunningMode::TEST {
            println!("*** TEST MODE ***");
        } else if RUNNING_MODE == RunningMode::SIMUL {
            println!("*** SIMULATION MODE ***");
        }

        // pre-fetching candle data: 30m, 1d, 1w and 1mon
        print!("pre-fetching candle data: 30m, 1d, 1w and 1mon..");
        std::io::stdout().flush();
        let instant = Instant::now();
        let interval_30m = String::from("30m");
        let interval_1d = String::from("1d");
        let interval_1w = String::from("1w");
        let interval_1mon = String::from("1mon");

        let mut candle_30m_vec_temp: Vec<(String, Vec<CandleData>)> = Vec::new();
        let mut candle_1d_vec_temp: Vec<(String, Vec<CandleData>)> = Vec::new();
        let mut candle_1w_vec_temp: Vec<(String, Vec<CandleData>)> = Vec::new();
        let mut candle_1mon_vec_temp: Vec<(String, Vec<CandleData>)> = Vec::new();

        request_candles::fetch_candle_parallel(&interval_30m, &mut candle_30m_vec_temp).await;
        request_candles::fetch_candle_parallel(&interval_1d, &mut candle_1d_vec_temp).await;
        request_candles::fetch_candle_parallel(&interval_1w, &mut candle_1w_vec_temp).await;
        request_candles::fetch_candle_parallel(&interval_1mon, &mut candle_1mon_vec_temp).await;

        tx_candle_30m_vec.send_modify(|vec| *vec = candle_30m_vec_temp);
        tx_candle_1d_vec.send_modify(|vec| *vec = candle_1d_vec_temp);
        tx_candle_1w_vec.send_modify(|vec| *vec = candle_1w_vec_temp);
        tx_candle_1mon_vec.send_modify(|vec| *vec = candle_1mon_vec_temp);

        // sleep as much as the loop recurs per 60 seconds, expecting child threads will have finished within 60 seconds.
        println!("Ok..");

        if RUNNING_MODE == REAL || RUNNING_MODE == SIMUL {
            let mut elapsed_time = instant.elapsed().as_secs();
            let mut remaining_time: u64 = 60 - elapsed_time;

            while remaining_time > 0 && 60 > remaining_time {
                print!("\rstart tradingbot in {} seconds", remaining_time);
                io::stdout().flush();
                elapsed_time = instant.elapsed().as_secs();
                loop {
                    let temp_elapsed_time = instant.elapsed().as_secs();
                    let is_overflowed = remaining_time.overflowing_sub(1).1;

                    if is_overflowed == true {
                        break;
                    }
                    if elapsed_time < temp_elapsed_time {
                        remaining_time -= 1;
                        break;
                    }
                }
            }

            println!("\nTradingbot is running");
        }
    }

    // Task#0: monitoring tasks
    tokio::task::spawn(async move {
        loop {
            let result = rx_task0.recv().await;

            match result {
                Some(1) => {
                    print!("\r1[■] 2[ ] 3[ ] 4[ ] 5[ ] 6[ ] 7[ ] 8[ ] 9[ ] 12[ ] 13[ ] 14[ ] 15[ ] 16[ ] 17[ ] 18[ ] 19[ ] 20[ ] 21[ ] 22[ ] 23[ ] 24[ ] 25[ ] 26[ ]");
                    io::stdout().flush();
                }
                Some(2) => {
                    print!("\r1[ ] 2[■] 3[ ] 4[ ] 5[ ] 6[ ] 7[ ] 8[ ] 9[ ] 12[ ] 13[ ] 14[ ] 15[ ] 16[ ] 17[ ] 18[ ] 19[ ] 20[ ] 21[ ] 22[ ] 23[ ] 24[ ] 25[ ] 26[ ]");
                    io::stdout().flush();
                }
                Some(3) => {
                    print!("\r1[ ] 2[ ] 3[■] 4[ ] 5[ ] 6[ ] 7[ ] 8[ ] 9[ ] 12[ ] 13[ ] 14[ ] 15[ ] 16[ ] 17[ ] 18[ ] 19[ ] 20[ ] 21[ ] 22[ ] 23[ ] 24[ ] 25[ ] 26[ ]");
                    io::stdout().flush();
                }
                Some(4) => {
                    print!("\r1[ ] 2[ ] 3[ ] 4[■] 5[ ] 6[ ] 7[ ] 8[ ] 9[ ] 12[ ] 13[ ] 14[ ] 15[ ] 16[ ] 17[ ] 18[ ] 19[ ] 20[ ] 21[ ] 22[ ] 23[ ] 24[ ] 25[ ] 26[ ]");
                    io::stdout().flush();
                }
                Some(5) => {
                    print!("\r1[ ] 2[ ] 3[ ] 4[ ] 5[■] 6[ ] 7[ ] 8[ ] 9[ ] 12[ ] 13[ ] 14[ ] 15[ ] 16[ ] 17[ ] 18[ ] 19[ ] 20[ ] 21[ ] 22[ ] 23[ ] 24[ ] 25[ ] 26[ ]");
                    io::stdout().flush();
                }
                Some(6) => {
                    print!("\r1[ ] 2[ ] 3[ ] 4[ ] 5[ ] 6[■] 7[ ] 8[ ] 9[ ] 12[ ] 13[ ] 14[ ] 15[ ] 16[ ] 17[ ] 18[ ] 19[ ] 20[ ] 21[ ] 22[ ] 23[ ] 24[ ] 25[ ] 26[ ]");
                    io::stdout().flush();
                }
                Some(7) => {
                    print!("\r1[ ] 2[ ] 3[ ] 4[ ] 5[ ] 6[ ] 7[■] 8[] 9[ ] 12[ ] 13[ ] 14[ ] 15[ ] 16[ ] 17[ ] 18[ ] 19[ ] 20[ ] 21[ ] 22[ ] 23[ ] 24[ ] 25[ ] 26[ ]");
                    io::stdout().flush();
                }
                Some(8) => {
                    print!("\r1[ ] 2[ ] 3[ ] 4[ ] 5[ ] 6[ ] 7[ ] 8[■ 9[ ] 12[ ] 13[ ] 14[ ] 15[ ] 16[ ] 17[ ] 18[ ] 19[ ] 20[ ] 21[ ] 22[ ] 23[ ] 24[ ] 25[ ] 26[ ]");
                    io::stdout().flush();
                }
                Some(9) => {
                    print!("\r1[ ] 2[ ] 3[ ] 4[ ] 5[ ] 6[ ] 7[ ] 8[ ] 9[■] 12[ ] 13[ ] 14[ ] 15[ ] 16[ ] 17[ ] 18[ ] 19[ ] 20[ ] 21[ ] 22[ ] 23[ ] 24[ ] 25[ ] 26[ ]");
                    io::stdout().flush();
                }
                Some(12) => {
                    print!("\r1[ ] 2[ ] 3[ ] 4[ ] 5[ ] 6[ ] 7[ ] 8[ ] 9[ ] 12[■] 13[ ] 14[ ] 15[ ] 16[ ] 17[ ] 18[ ] 19[ ] 20[ ] 21[ ] 22[ ] 23[ ] 24[ ] 25[ ] 26[ ]");
                    io::stdout().flush();
                }
                Some(13) => {
                    print!("\r1[ ] 2[ ] 3[ ] 4[ ] 5[ ] 6[ ] 7[ ] 8[ ] 9[ ] 12[ ] 13[■] 14[ ] 15[ ] 16[ ] 17[ ] 18[ ] 19[ ] 20[ ] 21[ ] 22[ ] 23[ ] 24[ ] 25[ ] 26[ ]");
                    io::stdout().flush();
                }
                Some(14) => {
                    print!("\r1[ ] 2[ ] 3[ ] 4[ ] 5[ ] 6[ ] 7[ ] 8[ ] 9[ ] 12[ ] 13[ ] 14[■] 15[ ] 16[ ] 17[ ] 18[ ] 19[ ] 20[ ] 21[ ] 22[ ] 23[ ] 24[ ] 25[ ] 26[ ]");
                    io::stdout().flush();
                }
                Some(15) => {
                    print!("\r1[ ] 2[ ] 3[ ] 4[ ] 5[ ] 6[ ] 7[ ] 8[ ] 9[ ] 12[ ] 13[ ] 14[ ] 15[■] 16[ ] 17[ ] 18[ ] 19[ ] 20[ ] 21[ ] 22[ ] 23[ ] 24[ ] 25[ ] 26[ ]");
                    io::stdout().flush();
                }
                Some(16) => {
                    print!("\r1[ ] 2[ ] 3[ ] 4[ ] 5[ ] 6[ ] 7[ ] 8[ ] 9[ ] 12[ ] 13[ ] 14[ ] 15[ ] 16[■] 17[ ] 18[ ] 19[ ] 20[ ] 21[ ] 22[ ] 23[ ] 24[ ] 25[ ] 26[ ]");
                    io::stdout().flush();
                }
                Some(17) => {
                    print!("\r1[ ] 2[ ] 3[ ] 4[ ] 5[ ] 6[ ] 7[ ] 8[ ] 9[ ] 12[ ] 13[ ] 14[ ] 15[ ] 16[ ] 17[■] 18[ ] 19[ ] 20[ ] 21[ ] 22[ ] 23[ ] 24[ ] 25[ ] 26[ ]");
                    io::stdout().flush();
                }
                Some(18) => {
                    print!("\r1[ ] 2[ ] 3[ ] 4[ ] 5[ ] 6[ ] 7[ ] 8[ ] 9[ ] 12[ ] 13[ ] 14[ ] 15[ ] 16[ ] 17[ ] 18[■] 19[ ] 20[ ] 21[ ] 22[ ] 23[ ] 24[ ] 25[ ] 26[ ]");
                    io::stdout().flush();
                }
                Some(19) => {
                    print!("\r1[ ] 2[ ] 3[ ] 4[ ] 5[ ] 6[ ] 7[ ] 8[ ] 9[ ] 12[ ] 13[ ] 14[ ] 15[ ] 16[ ] 17[ ] 18[ ] 19[■] 20[ ] 21[ ] 22[ ] 23[ ] 24[ ] 25[ ] 26[ ]");
                    io::stdout().flush();
                }
                Some(20) => {
                    print!("\r1[ ] 2[ ] 3[ ] 4[ ] 5[ ] 6[ ] 7[ ] 8[ ] 9[ ] 12[ ] 13[ ] 14[ ] 15[ ] 16[ ] 17[ ] 18[ ] 19[ ] 20[■] 21[ ] 22[ ] 23[ ] 24[ ] 25[ ] 26[ ]");
                    io::stdout().flush();
                }
                Some(21) => {
                    print!("\r1[ ] 2[ ] 3[ ] 4[ ] 5[ ] 6[ ] 7[ ] 8[ ] 9[ ] 12[ ] 13[ ] 14[ ] 15[ ] 16[ ] 17[ ] 18[ ] 19[ ] 20[ ] 21[■] 22[ ] 23[ ] 24[ ] 25[ ] 26[ ]");
                    io::stdout().flush();
                }
                Some(22) => {
                    print!("\r1[ ] 2[ ] 3[ ] 4[ ] 5[ ] 6[ ] 7[ ] 8[ ] 9[ ] 12[ ] 13[ ] 14[ ] 15[ ] 16[ ] 17[ ] 18[ ] 19[ ] 20[ ] 21[ ] 22[■] 23[ ] 24[ ] 25[ ] 26[ ]");
                    io::stdout().flush();
                }
                Some(23) => {
                    print!("\r1[ ] 2[ ] 3[ ] 4[ ] 5[ ] 6[ ] 7[ ] 8[ ] 9[ ] 12[ ] 13[ ] 14[ ] 15[ ] 16[ ] 17[ ] 18[ ] 19[ ] 20[ ] 21[ ] 22[ ] 23[■] 24[ ] 25[ ] 26[ ]");
                    io::stdout().flush();
                }
                Some(24) => {
                    print!("\r1[ ] 2[ ] 3[ ] 4[ ] 5[ ] 6[ ] 7[ ] 8[ ] 9[ ] 12[ ] 13[ ] 14[ ] 15[ ] 16[ ] 17[ ] 18[ ] 19[ ] 20[ ] 21[ ] 22[ ] 23[ ] 24[■] 25[ ] 26[ ]");
                    io::stdout().flush();
                }
                Some(25) => {
                    print!("\r1[ ] 2[ ] 3[ ] 4[ ] 5[ ] 6[ ] 7[ ] 8[ ] 9[ ] 12[ ] 13[ ] 14[ ] 15[ ] 16[ ] 17[ ] 18[ ] 19[ ] 20[ ] 21[ ] 22[ ] 23[ ] 24[ ] 25[■] 26[ ]");
                    io::stdout().flush();
                }
                Some(26) => {
                    print!("\r1[ ] 2[ ] 3[ ] 4[ ] 5[ ] 6[ ] 7[ ] 8[ ] 9[ ] 12[ ] 13[ ] 14[ ] 15[ ] 16[ ] 17[ ] 18[ ] 19[ ] 20[ ] 21[ ] 22[ ] 23[ ] 24[ ] 25[ ] 26[■]");
                    io::stdout().flush();
                }
                Some(_) => {}
                None => {}
            }
            sleep(Duration::from_millis(50)).await;
        }
    });

    // Task#1: check server time and health
    tokio::task::spawn(async move {
        let client = ClientBuilder::new()
            .timeout(Duration::from_millis(1000))
            .build()
            .unwrap();
        let mut usertime = UserTime::new();
        let mut serverhealth = ServerHealth::new();
        let mut prev_server_epoch: u128 = 0;
        let mut epoch_difference: f64 = 0.0;
        let mut epoch_difference_vec: Vec<f64> = Vec::new();
        let mut epoch_mean: f64 = 0.0;
        let mut elapsed_time: u128 = 0;

        loop {
            let instant = Instant::now();

            // let mut usertime_mutex = usertime_arc.lock().await;
            // server_health_check_team::execute_server_health_check(&mut usertime_mutex).await;
            // time_checking_team::execute_time_check(&mut usertime_mutex).await;
            let result = server_health_check_team::execute_server_health_check(
                &mut usertime,
                &mut serverhealth,
                &client,
            )
            .await;
            while let Err(E) = time_checking_team::execute_time_check(&mut usertime, &client).await
            {
                sleep(Duration::from_millis((100))).await;
                while let Err(e) = server_health_check_team::execute_server_health_check(
                    &mut usertime,
                    &mut serverhealth,
                    &client,
                )
                .await
                {}
            }

            match result {
                Ok(T) => {
                    tx1.send(usertime.local_epoch)
                        .expect("tx1-rx1 channel has been closed.");
                    tx2.send(usertime.epoch_difference)
                        .expect("tx2-rx2 channel has been closed.");
                    tx_task1.send(1).expect("The mpsc channel has been closed.");
                }
                Err(E) => {}
            }

            // sleep as much as the loop recurs per 1 second if all operation finished within 1 second.
            // considering RTT and to make the wait time 1 second, latency each second for every 30 seconds is averaged and subtracted with wait time.
            elapsed_time = instant.elapsed().as_millis();
            if 1_000 > elapsed_time {
                if prev_server_epoch != 0 {
                    epoch_mean = 0.0;

                    epoch_difference =
                        (usertime.server_epoch as f64) - (prev_server_epoch as f64) - 1000.0; // milli second

                    if epoch_difference > 300.0 || epoch_difference < -300.0 {
                        epoch_difference_vec.clear();
                        epoch_difference = 0.0;
                    }

                    if epoch_difference_vec.len() == 10 {
                        epoch_difference_vec.rotate_left(1);
                        epoch_difference_vec.pop();
                        epoch_difference_vec.push(epoch_difference);
                    } else if epoch_difference_vec.len() < 10 {
                        epoch_difference_vec.push(epoch_difference);
                    }
                    for element in &epoch_difference_vec {
                        epoch_mean += *element;
                    }
                    epoch_mean = epoch_mean / (epoch_difference_vec.len() as f64);
                }
                if epoch_mean > 0.0 {
                    if elapsed_time > ((epoch_mean) as u128)
                        && 1_000 > elapsed_time + ((epoch_mean) as u128)
                    {
                        sleep(Duration::from_millis(
                            (1_000 - elapsed_time - ((epoch_mean) as u128)) as u64,
                        ))
                        .await;
                    } else {
                        sleep(Duration::from_millis((1_000 - elapsed_time) as u64)).await;
                    }
                } else {
                    sleep(Duration::from_millis(
                        (1_000 - elapsed_time + ((epoch_mean.abs()) as u128)) as u64,
                    ))
                    .await;
                }
            }
            prev_server_epoch = usertime.server_epoch;
        }
    });

    // Task#2: request trade fee
    tokio::task::spawn(async move {
        let client = ClientBuilder::new()
            .timeout(tokio::time::Duration::from_millis(3000))
            .build()
            .unwrap();
        let mut elapsed_time = 0;
        loop {
            let instant = Instant::now();
            let tx1_changed = rx1_1.changed().await;
            let tx2_changed = rx2.changed().await;
            let local_epoch = *rx1_1.borrow();
            let difference_epoch = *rx2.borrow();
            match tx1_changed {
                Ok(T) => match tx2_changed {
                    Ok(T) => {
                        let mut tradefee_vec_temp: Vec<TradeFee> = Vec::new();
                        let mut result;
                        loop {
                            result = request_others::request_trade_fee(
                                API_KEY,
                                SECRET_KEY,
                                local_epoch,
                                difference_epoch,
                                &client,
                                &mut tradefee_vec_temp,
                            )
                            .await;

                            if tradefee_vec_temp.len() == 0 {
                                sleep(Duration::from_secs(3)).await;
                            } else {
                                break;
                            }
                        }

                        match result {
                            Ok(T) => {
                                tx_tradefee_vec.send_modify(|vec| *vec = tradefee_vec_temp);
                                tx_task2.send(2).expect("The mpsc channel has been closed.");
                            }
                            Err(E) => {}
                        }
                    }
                    Err(E) => {
                        panic!("tx2-rx2 channel has been closed.")
                    }
                },
                Err(E) => {
                    panic!("tx1-rx1 channel has been closed.")
                }
            }

            // sleep as much as the loop recurs per 60 seconds if all operation finished within 60 seconds.
            elapsed_time = instant.elapsed().as_millis();
            if 60_000 > elapsed_time {
                sleep(Duration::from_millis((60_000 - elapsed_time) as u64)).await;
            }
        }
    });

    // Task#3: request lot stepsize and ticksize
    tokio::task::spawn(async move {
        let client = ClientBuilder::new()
            .timeout(tokio::time::Duration::from_millis(3000))
            .build()
            .unwrap();
        loop {
            let mut exchange_info_data_temp: Vec<ExchangeInfo> = Vec::new();
            let mut result;
            loop {
                result = coin_health_check_team::request_others::request_exchange_infomation(
                    &client,
                    &mut exchange_info_data_temp,
                )
                .await;

                // retry
                if exchange_info_data_temp.len() == 0 {
                    sleep(Duration::from_secs(3)).await;
                } else {
                    break;
                }
            }

            match result {
                Ok(T) => {
                    tx_exchange_info_data.send_modify(|vec| *vec = exchange_info_data_temp);
                    tx_task3.send(3).expect("The mpsc channel has been closed.");
                }
                Err(E) => {}
            }
            sleep(Duration::from_secs(300)).await; // sleep for 5 mins
        }
    });

    // Task#4: request 24h price changes,
    // pick valid USDT Trades,
    // filtering stop USDT Trades,
    // monitor total_24h_change_profit_index,
    // usdt_24h_change_profit_index,
    // total_price_down_dist_index
    tokio::task::spawn(async move {
        sleep(Duration::from_secs(10)).await;
        let client = ClientBuilder::new()
            .timeout(tokio::time::Duration::from_millis(3000))
            .build()
            .unwrap();
        let mut elapsed_time = 0;
        loop {
            let instant = Instant::now();
            let result = request_others::request_24hr_ticker_price_change_statistics(&client).await;
            match result {
                Ok(T) => {
                    let exchange_info_vec = rx5_exchange_info_data.borrow().clone();
                    let mut valid_usdt_trade_vec_temp: Vec<String> = Vec::new();
                    let result = monitors::collect_valid_usde_trade(
                        &mut valid_usdt_trade_vec_temp,
                        &exchange_info_vec,
                    )
                    .await;

                    match result {
                        Ok(T) => {
                            tx_valid_usdt_trade_vec
                                .send_modify(|vec| *vec = valid_usdt_trade_vec_temp);
                            tx_task4.send(4).expect("The mpsc channel has been closed.");
                        }
                        Err(E) => {}
                    }
                }
                Err(E) => {
                    println!(">>> Failed to monitor usdt_24h_change_profit_index.");
                }
            }
            // match result {
            //     Ok(T) => {
            //         let result = monitors::total_24h_change_profit_index().await;
            //         match result {
            //             Ok(T) => {},
            //             Err(E) => {
            //                 println!(">>> Failed to monitor total_24h_change_profit_index.");
            //             }
            //         };

            //         let result = monitors::usdt_24h_change_profit_index().await;
            //         match result {
            //             Ok(T) => {},
            //             Err(E) => {
            //                 println!(">>> Failed to monitor usdt_24h_change_profit_index.");
            //             }
            //         };

            //         let result = monitors::total_price_down_dist_index().await;
            //         match result {
            //             Ok(T) => {},
            //             Err(E) => {
            //                 println!(">>> Failed to monitor total_price_down_dist_index.");
            //             }
            //         };
            //     },
            //     Err(E) => {
            //         println!(">>> Failed to fetch 24h price change data from endpoint or parse message.");
            //     }
            // };

            // sleep as much as the loop recurs per 30 seconds if all operation finished within 30 seconds.
            elapsed_time = instant.elapsed().as_millis();
            if 30_000 > elapsed_time {
                sleep(Duration::from_millis((30_000 - elapsed_time) as u64)).await;
            }
        }
    });

    // Task#5: price per second
    tokio::task::spawn(async move {
        sleep(Duration::from_secs(20)).await;
        let client = ClientBuilder::new()
            .timeout(tokio::time::Duration::from_millis(1000))
            .build()
            .unwrap();
        let mut server_epoch = 0;
        let mut elapsed_time = 0;
        loop {
            let instant = Instant::now();

            let mut price_vec_temp: Vec<CoinPriceData> = Vec::new();
            let result = request_others::request_all_coin_price(&client, &mut price_vec_temp).await;
            let mut price_vec_temp_c: Vec<CoinPriceData> = Vec::new();
            match result {
                Ok(T) => {
                    price_vec_temp_c = price_vec_temp.clone();
                    tx_price_vec.send_modify(|vec| *vec = price_vec_temp);
                    tx_task5.send(5).expect("The mpsc channel has been closed.");
                }
                Err(E) => {}
            }

            // Task#10: make realtime price data of 1m, 30m, 1d, 1w and 1mon
            let valid_usdt_trade_vec = rx_valid_usdt_trade_vec.borrow().clone();
            // 1m
            let interval = String::from("1m");
            let candle_1m_vec = rx_candle_1m_vec.borrow().clone();
            let rt_price_1m_vec_read_temp: Vec<(String, Vec<RealtimePriceData>)> = Vec::new();
            let mut rt_price_1m_vec_write_temp: Vec<(String, Vec<RealtimePriceData>)> = Vec::new();
            let result = value_estimation_team::datapoints::price_data::update_realtime_price_data(
                &interval,
                &candle_1m_vec,
                &rt_price_1m_vec_read_temp,
                &mut rt_price_1m_vec_write_temp,
                &price_vec_temp_c,
                &valid_usdt_trade_vec,
            )
            .await;

            match result {
                Ok(T) => {
                    if tx_rt_price_1m_vec.is_closed() {
                        eprintln!("tx_rt_price_1m_vec has been closed!");
                    } else {
                        tx_rt_price_1m_vec.send_modify(|vec| *vec = rt_price_1m_vec_write_temp);
                    }
                }
                Err(E) => {}
            }

            // 30m
            let interval = String::from("30m");
            let candle_30m_vec = rx_candle_30m_vec.borrow().clone();
            let rt_price_1m_vec = rx_rt_price_1m_vec.borrow().clone();
            let mut rt_price_30m_vec_write_temp: Vec<(String, Vec<RealtimePriceData>)> = Vec::new();

            if !rt_price_1m_vec.is_empty() {
                let result =
                    value_estimation_team::datapoints::price_data::update_realtime_price_data(
                        &interval,
                        &candle_30m_vec,
                        &rt_price_1m_vec,
                        &mut rt_price_30m_vec_write_temp,
                        &price_vec_temp_c,
                        &valid_usdt_trade_vec,
                    )
                    .await;

                match result {
                    Ok(T) => {
                        if tx_rt_price_30m_vec.is_closed() {
                            eprintln!("tx_rt_price_30m_vec has been closed!");
                        } else {
                            tx_rt_price_30m_vec
                                .send_modify(|vec| *vec = rt_price_30m_vec_write_temp);
                        }
                    }
                    Err(E) => {}
                }
            }

            // 1d
            let interval = String::from("1d");
            let candle_1d_vec = rx_candle_1d_vec.borrow().clone();
            let rt_price_30m_vec = rx_rt_price_30m_vec.borrow().clone();
            let mut rt_price_1d_vec_write_temp: Vec<(String, Vec<RealtimePriceData>)> = Vec::new();

            if !rt_price_30m_vec.is_empty() {
                let result =
                    value_estimation_team::datapoints::price_data::update_realtime_price_data(
                        &interval,
                        &candle_1d_vec,
                        &rt_price_30m_vec,
                        &mut rt_price_1d_vec_write_temp,
                        &price_vec_temp_c,
                        &valid_usdt_trade_vec,
                    )
                    .await;

                match result {
                    Ok(T) => {
                        if tx_rt_price_1d_vec.is_closed() {
                            eprintln!("tx_rt_price_1d_vec has been closed!");
                        } else {
                            tx_rt_price_1d_vec.send_modify(|vec| *vec = rt_price_1d_vec_write_temp);
                        }
                    }
                    Err(E) => {}
                }
            }

            // {   // 1w
            //     let interval = String::from("1w");
            //     let candle_1w_vec = rx_candle_1w_vec.borrow().clone();
            //     let rt_price_1d_vec = rx_rt_price_1d_vec.borrow().clone();
            //     let mut rt_price_1w_vec_write_temp: Vec<(String, Vec<RealtimePriceData>)> = Vec::new();
            //     let result = value_estimation_team::datapoints::price_data::update_realtime_price_data(&interval, &candle_1w_vec, &rt_price_1d_vec, &mut rt_price_1w_vec_write_temp, &price_vec_temp_c, &valid_usdt_trade_vec).await;

            //     match result {
            //         Ok(T) => {
            //             tx_rt_price_1w_vec.send_modify(|vec| *vec = rt_price_1w_vec_write_temp);
            //             tx_task10.send(10).expect("The mpsc channel has been closed.");
            //         }
            //         Err(E) => {}
            //     }
            // }

            // {   // 1mon
            //     let interval = String::from("1mon");
            //     let candle_1mon_vec = rx_candle_1mon_vec.borrow().clone();
            //     let rt_price_1w_vec = rx_rt_price_1w_vec.borrow().clone();
            //     let mut rt_price_1mon_vec_write_temp: Vec<(String, Vec<RealtimePriceData>)> = Vec::new();
            //     let result = value_estimation_team::datapoints::price_data::update_realtime_price_data(&interval, &candle_1mon_vec, &rt_price_1w_vec, &mut rt_price_1mon_vec_write_temp, &price_vec_temp_c, &valid_usdt_trade_vec).await;

            //     match result {
            //         Ok(T) => {
            //             tx_rt_price_1mon_vec.send_modify(|vec| *vec = rt_price_1mon_vec_write_temp);
            //             tx_task10.send(10).expect("The mpsc channel has been closed.");
            //         }
            //         Err(E) => {}
            //     }
            // }

            // sleep as much as the loop recurs per 1 seconds if all operation finished within 1 seconds.
            elapsed_time = instant.elapsed().as_millis();
            if 500 > elapsed_time {
                sleep(Duration::from_millis((500 - elapsed_time) as u64)).await;
            }
        }
    });

    // Task#6: fetch candle 1m
    tokio::task::spawn(async move {
        let mut elapsed_time = 0;
        let interval = String::from("1m");
        loop {
            let instant = Instant::now();
            let mut candle_1m_vec_temp: Vec<(String, Vec<CandleData>)> = Vec::new();
            let result =
                request_candles::fetch_candle_parallel(&interval, &mut candle_1m_vec_temp).await;

            match result {
                Ok(T) => {
                    tx_candle_1m_vec.send_modify(|vec| *vec = candle_1m_vec_temp);
                    tx_task6.send(6).expect("The mpsc channel has been closed.");
                }
                Err(E) => {}
            }

            // sleep as much as the loop recurs per 10 seconds, expecting child threads will have finished within 10 seconds.
            elapsed_time = instant.elapsed().as_millis();
            if 30_000 > elapsed_time {
                // 10_000 for major trade
                sleep(Duration::from_millis((30_000 - elapsed_time) as u64)).await;
            }
        }
    });

    // Task#7: fetch candle 30m
    tokio::task::spawn(async move {
        let mut elapsed_time = 0;
        let interval = String::from("30m");
        loop {
            let instant = Instant::now();
            let mut candle_30m_vec_temp: Vec<(String, Vec<CandleData>)> = Vec::new();
            let result =
                request_candles::fetch_candle_delay(&interval, &mut candle_30m_vec_temp).await;
            // request_candles::fetch_candle_parallel(&interval, &mut candle_30m_vec_temp).await;

            match result {
                Ok(T) => {
                    tx_candle_30m_vec.send_modify(|vec| *vec = candle_30m_vec_temp);
                    tx_task7.send(7).expect("The mpsc channel has been closed.");
                }
                Err(E) => {}
            }
            // sleep as much as the loop recurs per 60 seconds, expecting child threads will have finished within 60 seconds.
            elapsed_time = instant.elapsed().as_millis();
            if 60_000 > elapsed_time {
                //60_000
                sleep(Duration::from_millis((60_000 - elapsed_time) as u64)).await;
            }
        }
    });

    // Task#8: fetch candle 1d
    tokio::task::spawn(async move {
        let mut elapsed_time = 0;
        let interval = String::from("1d");
        sleep(Duration::from_secs(600)).await;
        loop {
            let instant = Instant::now();
            let mut candle_1d_vec_temp: Vec<(String, Vec<CandleData>)> = Vec::new();
            let result =
                request_candles::fetch_candle_delay(&interval, &mut candle_1d_vec_temp).await;

            match result {
                Ok(T) => {
                    tx_candle_1d_vec.send_modify(|vec| *vec = candle_1d_vec_temp);
                    tx_task8.send(8).expect("The mpsc channel has been closed.");
                }
                Err(E) => {}
            }
            // sleep as much as the loop recurs per 1800 seconds, expecting child threads will have finished within 1800 seconds.
            elapsed_time = instant.elapsed().as_secs();
            if 1_800 > elapsed_time {
                sleep(Duration::from_secs((1_800 - elapsed_time) as u64)).await;
            }
        }
    });

    // // Task#9: fetch candle 1w
    // tokio::task::spawn(async move{
    //     let interval = String::from("1w");
    //     sleep(Duration::from_secs(600)).await;
    //     loop{
    //         let mut candle_1w_vec_temp: Vec<(String, Vec<CandleData>)> = Vec::new();
    //         let result = request_candles::fetch_candle_delay(&interval, &mut candle_1w_vec_temp).await;

    //         match result {
    //             Ok(T) => {
    //                 tx_candle_1w_vec.send_modify(|vec| *vec = candle_1w_vec_temp);
    //                 tx_task9.send(9).expect("The mpsc channel has been closed.");
    //             }
    //             Err(E) => {}
    //         }
    //     }
    // });

    // // Task#10: fetch candle 1mon
    // tokio::task::spawn(async move{
    //     let interval = String::from("1mon");
    //     sleep(Duration::from_secs(600)).await;
    //     loop{
    //         let mut candle_1mon_vec_temp: Vec<(String, Vec<CandleData>)> = Vec::new();
    //         let result = request_candles::fetch_candle_delay(&interval, &mut candle_1mon_vec_temp).await;

    //         match result {
    //             Ok(T) => {
    //                 tx_candle_1mon_vec.send_modify(|vec| *vec = candle_1mon_vec_temp);
    //                 tx_task10.send(10).expect("The mpsc channel has been closed.");
    //             }
    //             Err(E) => {}
    //         }
    //     }
    // });

    // Task#11: monitoring total market cap
    if RUNNING_MODE == REAL || RUNNING_MODE == SIMUL || RUNNING_MODE == TEST {
        tokio::task::spawn(async move {
            loop {
                let result = signal_association::coinmarketcap::market_cap_index().await;
                match result {
                    Ok(T) => {
                        tx_task11
                            .send(11)
                            .expect("The mpsc channel has been closed.");
                    }
                    Err(E) => {}
                }
            }
        });
    }

    // Task#12: monitoring foreign exchange rate
    if RUNNING_MODE == REAL || RUNNING_MODE == SIMUL {
        tokio::task::spawn(async move {
            loop {
                let result = signal_association::exchange_rate::monitoring_fx_rate_index().await;
                match result {
                    Ok(T) => {
                        tx_task12
                            .send(12)
                            .expect("The mpsc channel has been closed.");
                    }
                    Err(E) => {}
                }
                sleep(Duration::from_secs(2700)).await; // sleep for 45mins
            }
        });
    }

    // // // Task#13: monitoring dollar index
    // // tokio::task::spawn(async move {
    // //     loop
    // //     {
    // //         let result = signal_association::dollar_index::monitoring_dollar_index().await;
    // //         match result {
    // //             Ok(T) => {
    // //                 tx_task13.send(13).expect("The mpsc channel has been closed.");
    // //             }
    // //             Err(E) => {}
    // //         }
    // //         sleep(Duration::from_secs(1800)).await; // sleep for 30mins
    // //     }
    // // });

    // Task#14: monitoring signal decision
    if RUNNING_MODE == REAL || RUNNING_MODE == SIMUL || RUNNING_MODE == TEST {
        tokio::task::spawn(async move {
            loop {
                let result =
                    signal_association::signal_decision::monitoring_signal_decision().await;
                match result {
                    Ok(T) => {
                        tx_task14
                            .send(14)
                            .expect("The mpsc channel has been closed.");
                    }
                    Err(E) => {}
                }

                sleep(Duration::from_millis(500)).await; // sleep for 0.5sec
            }
        });
    }

    // Task#15: monitoring future ratio
    if RUNNING_MODE == REAL || RUNNING_MODE == SIMUL || RUNNING_MODE == TEST {
        tokio::task::spawn(async move {
            loop {
                let result = signal_association::future_ratio::monitoring_future_ratio().await;
                match result {
                    Ok(T) => {
                        tx_task15
                            .send(15)
                            .expect("The mpsc channel has been closed.");
                    }
                    Err(E) => {}
                }

                sleep(Duration::from_secs(60)).await; // sleep for 1min
            }
        });
    }

    // COEX part
    // Task#16: execute strategis for buy
    if RUNNING_MODE == REAL || RUNNING_MODE == SIMUL {
        tokio::task::spawn(async move {
            sleep(Duration::from_secs(40)).await;
            let mut all_data = AllData::new();
            let mut elapsed_time = 0;
            loop {
                let instant = Instant::now();
                all_data.valid_symbol_vec = rx3_valid_usdt_trade_vec.borrow().clone();

                // realtime price data
                all_data.rt_price_1m_vec = rx3_rt_price_1m_vec.borrow().clone();
                all_data.rt_price_30m_vec = rx3_rt_price_30m_vec.borrow().clone();
                all_data.rt_price_1d_vec = rx3_rt_price_1d_vec.borrow().clone();
                all_data.rt_price_1w_vec = rx3_rt_price_1w_vec.borrow().clone();
                all_data.rt_price_1mon_vec = rx3_rt_price_1mon_vec.borrow().clone();

                let result =
                    strategy_team::strategy_manager::execute_list_up_for_buy(&all_data).await;

                match result {
                    Ok(T) => {
                        tx_task16
                            .send(16)
                            .expect("The mpsc channel has been closed.");
                    }
                    Err(E) => {
                        // eprintln!("Couldn't execute strategists.");
                    }
                }

                // sleep as much as the loop recurs per 1 second if all operation finished within 1 second.
                elapsed_time = instant.elapsed().as_millis();
                if 250 > elapsed_time {
                    sleep(Duration::from_millis((250 - elapsed_time) as u64)).await;
                }
            }
        });
    } else {
        tokio::task::spawn(async move {
            sleep(Duration::from_secs(10)).await;
            let mut elapsed_time = 0;
            let mut all_data = AllData::new();
            loop {
                let instant = Instant::now();
                all_data.valid_symbol_vec = rx3_valid_usdt_trade_vec.borrow().clone();
                // realtime price data
                all_data.rt_price_1m_vec = rx3_rt_price_1m_vec.borrow().clone();
                all_data.rt_price_30m_vec = rx3_rt_price_30m_vec.borrow().clone();
                all_data.rt_price_1d_vec = rx3_rt_price_1d_vec.borrow().clone();
                all_data.rt_price_1w_vec = rx3_rt_price_1w_vec.borrow().clone();
                all_data.rt_price_1mon_vec = rx3_rt_price_1mon_vec.borrow().clone();

                // let result = coex::strategy_team::execute_strategist_for_test(&all_data).await;

                // match result {
                //     Ok(T) => {
                //         tx_task16
                //             .send(16)
                //             .expect("The mpsc channel has been closed.");
                //     }
                //     Err(E) => {}
                // }

                // sleep as much as the loop recurs per 1 second if all operation finished within 1 second.
                elapsed_time = instant.elapsed().as_millis();
                if 250 > elapsed_time {
                    sleep(Duration::from_millis((250 - elapsed_time) as u64)).await;
                }
            }
        });
    }

    // Task#17: execute strategis for sell
    if RUNNING_MODE == REAL || RUNNING_MODE == SIMUL {
        tokio::task::spawn(async move {
            sleep(Duration::from_secs(40)).await;
            let mut all_data = AllData::new();
            let mut exchange_info_vec: Vec<ExchangeInfo> = Vec::new();
            let mut trade_fee_vec: Vec<TradeFee> = Vec::new();
            let mut elapsed_time = 0;
            loop {
                let instant = Instant::now();
                all_data.valid_symbol_vec = rx4_valid_usdt_trade_vec.borrow().clone();
                exchange_info_vec = rx6_exchange_info_data.borrow().clone();
                trade_fee_vec = rx5_tradefee_vec.borrow().clone();
                // realtime price data
                all_data.rt_price_1m_vec = rx5_rt_price_1m_vec.borrow().clone();
                all_data.rt_price_30m_vec = rx5_rt_price_30m_vec.borrow().clone();
                all_data.rt_price_1d_vec = rx4_rt_price_1d_vec.borrow().clone();
                all_data.rt_price_1w_vec = rx4_rt_price_1w_vec.borrow().clone();
                all_data.rt_price_1mon_vec = rx4_rt_price_1mon_vec.borrow().clone();

                let result = strategy_team::strategy_manager::execute_list_up_for_sell(
                    &all_data,
                    &exchange_info_vec,
                    &trade_fee_vec,
                )
                .await;

                match result {
                    Ok(T) => {
                        tx_task17
                            .send(17)
                            .expect("The mpsc channel has been closed.");
                    }
                    Err(E) => {
                        // eprintln!("Couldn't execute strategists.");
                    }
                }

                // sleep as much as the loop recurs per 1 second if all operation finished within 1 second.
                elapsed_time = instant.elapsed().as_millis();
                if 250 > elapsed_time {
                    sleep(Duration::from_millis((250 - elapsed_time) as u64)).await;
                }
            }
        });
    }

    // Task#18: monitoring pre-suggested coins
    tokio::task::spawn(async move {
        sleep(Duration::from_secs(30)).await;
        let mut elapsed_time = 0;
        loop {
            let instant = Instant::now();
            let coin_price_vec = rx3_price_vec.borrow().clone();
            let result = coex::exchange_team::monitoring_pre_suggested_coins(&coin_price_vec).await;

            // send Task#0 a message to notify running on
            match result {
                Ok(T) => {
                    tx_task18
                        .send(18)
                        .expect("The mpsc channel has been closed.");
                }
                Err(E) => {}
            }

            // sleep as much as the loop recurs per 1 second if all operation finished within 1 second.
            elapsed_time = instant.elapsed().as_millis();
            if 100 > elapsed_time {
                sleep(Duration::from_millis((100 - elapsed_time) as u64)).await;
            }
        }
    });

    // Task#19: buy_coin
    if RUNNING_MODE == REAL || RUNNING_MODE == SIMUL || RUNNING_MODE == TEST {
        tokio::task::spawn(async move {
            sleep(Duration::from_secs(30)).await;

            let mut elapsed_time = 0;
            loop {
                let instant = Instant::now();
                let exchange_info_vec = rx_exchange_info_data.borrow().clone();
                let trade_fee_vec = rx_tradefee_vec.borrow().clone();
                let result =
                    coex::exchange_team::buy_coin(&exchange_info_vec, &trade_fee_vec).await;

                // send Task#0 a message to notify running on
                match result {
                    Ok(T) => {
                        tx_task19
                            .send(19)
                            .expect("The mpsc channel has been closed.");
                    }
                    Err(E) => {
                        eprint!("Error: {:?}", E);
                    }
                }

                // sleep as much as the loop recurs per 200ms second if all operation finished within 200ms
                elapsed_time = instant.elapsed().as_millis();
                if 200 > elapsed_time {
                    sleep(Duration::from_millis((200 - elapsed_time) as u64)).await;
                }
            }
        });
    } else {
        tokio::task::spawn(async move {
            sleep(Duration::from_secs(15)).await;
            let mut elapsed_time = 0;

            let instant = Instant::now();
            let exchange_info_vec = rx_exchange_info_data.borrow().clone();
            let trade_fee_vec = rx_tradefee_vec.borrow().clone();
            // let result = coex::exchange_team::buy_coin_for_test(&client, &coin_price_vec, &exchange_info_vec, &trade_fee_vec).await;
            let result = coex::exchange_team::buy_coin(&exchange_info_vec, &trade_fee_vec).await;

            // send Task#0 a message to notify running on
            match result {
                Ok(T) => {
                    tx_task19
                        .send(19)
                        .expect("The mpsc channel has been closed.");
                }
                Err(E) => {}
            }

            // sleep as much as the loop recurs per 200ms second if all operation finished within 200ms
            elapsed_time = instant.elapsed().as_millis();
            if 200 > elapsed_time {
                sleep(Duration::from_millis((200 - elapsed_time) as u64)).await;
            }
        });
    }

    // Task#20: monitoring_open_buy_order
    if RUNNING_MODE == REAL || RUNNING_MODE == TEST {
        tokio::task::spawn(async move {
            if RUNNING_MODE == REAL {
                sleep(Duration::from_secs(30)).await;
            } else if RUNNING_MODE == TEST {
                sleep(Duration::from_secs(10)).await;
            }
            let client = ClientBuilder::new()
                .timeout(tokio::time::Duration::from_millis(3000))
                .build()
                .unwrap();
            let mut elapsed_time = 0;
            loop {
                let instant = Instant::now();
                let exchange_info_vec = rx3_exchange_info_data.borrow().clone();
                let trade_fee_vec = rx2_tradefee_vec.borrow().clone();
                let result = coex::order_team::monitoring_open_buy_order(
                    &client,
                    &exchange_info_vec,
                    &trade_fee_vec,
                )
                .await;

                // send Task#0 a message to notify running on
                match result {
                    Ok(T) => {
                        tx_task20
                            .send(20)
                            .expect("The mpsc channel has been closed.");
                    }
                    Err(E) => {}
                }

                // sleep as much as the loop recurs per 1 second if all operation finished within 1 second.
                elapsed_time = instant.elapsed().as_millis();
                if 200 > elapsed_time {
                    sleep(Duration::from_millis((200 - elapsed_time) as u64)).await;
                }
            }
        });
    }

    // Task#21: update_price_of_filled_buy_order
    tokio::task::spawn(async move {
        if RUNNING_MODE == TEST {
            sleep(Duration::from_secs(10)).await;
        } else {
            sleep(Duration::from_secs(30)).await;
        }
        let mut elapsed_time = 0;
        loop {
            let instant = Instant::now();
            let coin_price_vec = rx5_price_vec.borrow().clone();
            let exchange_info_vec = rx2_exchange_info_data.borrow().clone();
            let trade_fee_vec = rx3_tradefee_vec.borrow().clone();

            let result = coex::order_team::update_price_of_filled_buy_order(
                &coin_price_vec,
                &exchange_info_vec,
                &trade_fee_vec,
            )
            .await;

            // send Task#0 a message to notify running on
            match result {
                Ok(T) => {
                    tx_task21
                        .send(21)
                        .expect("The mpsc channel has been closed.");
                }
                Err(E) => {}
            }

            // sleep as much as the loop recurs per 1 second if all operation finished within 1 second.
            elapsed_time = instant.elapsed().as_millis();

            if 250 > elapsed_time {
                sleep(Duration::from_millis((250 - elapsed_time) as u64)).await;
            }
        }
    });

    // Task#22: monitoring_open_sell_order
    if RUNNING_MODE == REAL || RUNNING_MODE == TEST {
        tokio::task::spawn(async move {
            if RUNNING_MODE == REAL {
                sleep(Duration::from_secs(30)).await;
            } else if RUNNING_MODE == TEST {
                sleep(Duration::from_secs(10)).await;
            }
            let client = ClientBuilder::new()
                .timeout(tokio::time::Duration::from_millis(3000))
                .build()
                .unwrap();
            let mut elapsed_time = 0;
            loop {
                let instant = Instant::now();
                let exchange_info_vec = rx4_exchange_info_data.borrow().clone();
                let trade_fee_vec = rx4_tradefee_vec.borrow().clone();
                let result = coex::order_team::monitoring_open_sell_order(
                    &client,
                    &exchange_info_vec,
                    &trade_fee_vec,
                )
                .await;

                // send Task#0 a message to notify running on
                match result {
                    Ok(T) => {
                        tx_task22
                            .send(22)
                            .expect("The mpsc channel has been closed.");
                    }
                    Err(E) => {}
                }

                // sleep as much as the loop recurs per 1 second if all operation finished within 1 second.
                elapsed_time = instant.elapsed().as_millis();
                if 250 > elapsed_time {
                    sleep(Duration::from_millis((250 - elapsed_time) as u64)).await;
                }
            }
        });
    }

    // Task#23: monitoring_filled_sell_order
    tokio::task::spawn(async move {
        let client = ClientBuilder::new()
            .timeout(tokio::time::Duration::from_millis(3000))
            .build()
            .unwrap();
        let mut elapsed_time = 0;
        loop {
            let instant = Instant::now();
            let result = coex::order_team::monitoring_filled_sell_order(&client).await;

            // send Task#0 a message to notify running on
            match result {
                Ok(T) => {
                    tx_task23
                        .send(23)
                        .expect("The mpsc channel has been closed.");
                }
                Err(E) => {}
            }

            // sleep as much as the loop recurs per 1 second if all operation finished within 1 second.
            elapsed_time = instant.elapsed().as_millis();
            if 200 > elapsed_time {
                sleep(Duration::from_millis((200 - elapsed_time) as u64)).await;
            }
        }
    });

    // Task#24: monitoring_scoreboard
    tokio::task::spawn(async move {
        let mut elapsed_time = 0;
        let mut all_data = AllData::new();
        loop {
            let instant = Instant::now();

            // realtime price data
            all_data.rt_price_1m_vec = rx4_rt_price_1m_vec.borrow().clone();

            let result = coex::exchange_team::monitoring_scoreboard(&all_data).await;

            // send Task#0 a message to notify running on
            match result {
                Ok(T) => {
                    tx_task24
                        .send(24)
                        .expect("The mpsc channel has been closed.");
                }
                Err(E) => {}
            }

            // sleep as much as the loop recurs per 1 second if all operation finished within 1 second.
            elapsed_time = instant.elapsed().as_millis();
            if 200 > elapsed_time {
                sleep(Duration::from_millis((200 - elapsed_time) as u64)).await;
            }
        }
    });

    // Task#25: update current_total_usdt and available_usdt
    tokio::task::spawn(async move {
        let client = ClientBuilder::new()
            .timeout(tokio::time::Duration::from_millis(3000))
            .build()
            .unwrap();
        let mut previous_result = false;
        let mut elapsed_time = 0;
        loop {
            let instant = Instant::now();
            let result =
                coex::assets_managing_team::monitoring_asset_usdt(&mut previous_result, &client)
                    .await;

            // send Task#0 a message to notify running on
            match result {
                Ok(T) => {
                    tx_task25
                        .send(25)
                        .expect("The mpsc channel has been closed.");
                }
                Err(E) => {
                    println!("{}", E);
                }
            }

            // sleep as much as the loop recurs per 300ms if all operation finished within 300ms.
            elapsed_time = instant.elapsed().as_millis();
            if 250 > elapsed_time {
                sleep(Duration::from_millis((250 - elapsed_time) as u64)).await;
            }
        }
    });

    // Task#26: update kelly_criterion
    tokio::task::spawn(async move {
        let mut elapsed_time = 0;
        loop {
            let instant = Instant::now();
            let result = coex::assets_managing_team::update_kelly_criterion().await;

            // send Task#0 a message to notify running on
            match result {
                Ok(T) => {
                    tx_task26
                        .send(26)
                        .expect("The mpsc channel has been closed.");
                }
                Err(E) => {
                    println!("{}", E);
                }
            }

            // sleep as much as the loop recurs per 1 minutes
            elapsed_time = instant.elapsed().as_secs();
            if 60 > elapsed_time {
                sleep(Duration::from_secs((60 - elapsed_time) as u64)).await;
            }
        }
    });

    loop {
        // println!("test limit order 실행");
        // let client = ClientBuilder::new().timeout(Duration::from_millis(1000)).build().unwrap();
        // limit_order_buy_test(&client).await;
        sleep(Duration::from_secs(300000000000)).await;
    }

    Ok(())
}

// #![allow(unused)]
// #![allow(warnings)]

// mod assets_managing_team;
// mod database_control;
// mod value_estimation_team;
// mod plotting_team;
// mod request_test;

// use std::sync::{Arc};
// use reqwest::{Client, ClientBuilder};
// use tokio::{task::*, time::*, sync::watch, join, fs::*};
// use sqlx::{ mysql::*, Executor, Connection, FromRow, Row };

// pub const DB_URL: &str  = "mysql://root:Durtkarovh23!@localhost:3306/tradingbot";

// #[tokio::main]
// async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>>{
//     let (tx1, mut rx1) = watch::channel(0);
//     let mut rx2 = rx1.clone();

//     let mut cnt = 0;

//     tokio::task::spawn(async move{
//         loop{
//                 println!("Task #1: {}", cnt);
//                 tx1.send(cnt).expect("tx1-rx1 channel has been closed.");
//                 cnt += 1;
//                 sleep(Duration::from_secs(1)).await;

//         }
//     });

//     tokio::task::spawn(async move{
//         loop{
//                 let tx1_changed = rx1.changed().await;

//                 match tx1_changed {
//                     Ok(T) => {
//                         println!("      Task #2: {:?}", rx1.borrow());
//                     }
//                     Err(E) => {
//                         println!(">>> Failed to fetch tradefee data from endpoint or parse message.");
//                     }
//                 }

//         }
//     });

//     tokio::task::spawn(async move{
//         loop{
//             let tx1_changed = rx2.changed().await;

//             match tx1_changed {
//                 Ok(T) => {
//                     println!("                  Task #3: {:?}", rx2.borrow());
//                 }
//                 Err(E) => {
//                     println!(">>> Failed to fetch tradefee data from endpoint or parse message.");
//                 }
//             }
//             println!("what");

//         }
//     });
//     // let client = ClientBuilder::new().connect_timeout(tokio::time::Duration::from_millis(1200)).build().unwrap();

//     loop{
//         // request_test::request_candlestick_data(&client).await;

//         // plotting_team::plot_dp_mean_open_close_candle().await;
//         // value_estimation_team::mean_price_for24h_candle_30m().await;
//         // let job2 =
//         // let job3 =
//         // join!(job1);

//         // let job4 = tokio::task::spawn(assets_managing_team::request_wallet_info(api_key, secret_key, time.return_from_local_epoch(), time.return_difference_epoch()));

//         // tokio::join!(j1, j2, j3, j4, j5);
//         println!("main ended!");
//         sleep(Duration::from_secs(6)).await;
//     }

//     Ok(())
// }

// // use plotters::prelude::*;
// // fn main() -> Result<(), Box<dyn std::error::Error>> {
// //     let root = BitMapBackend::new("plotters-doc-data/0.png", (640, 480)).into_drawing_area();
// //     root.fill(&WHITE)?;
// //     let mut chart = ChartBuilder::on(&root)
// //         .caption("y=x^2", ("sans-serif", 50).into_font())
// //         .margin(5)
// //         .x_label_area_size(30)
// //         .y_label_area_size(30)
// //         .build_cartesian_2d(-1f32..1f32, -0.1f32..1f32)?;
// //
// //     chart.configure_mesh().draw()?;
// //
// //     chart
// //         .draw_series(LineSeries::new(
// //             (-50..=50).map(|x| x as f32 / 50.0).map(|x| (x, x * x)),
// //             &RED,
// //         ))?
// //         .label("y = x^2")
// //         .legend(|(x, y)| PathElement::new(vec![(x, y), (x + 20, y)], &RED));
// //
// //     chart
// //         .configure_series_labels()
// //         .background_style(&WHITE.mix(0.8))
// //         .border_style(&BLACK)
// //         .draw()?;
// //
// //     Ok(())
// // }