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

use super::HashMap;
use crate::database_control::*;
use crate::strategy_team::FilteredDataValue;
use crate::value_estimation_team::datapoints::price_data::RealtimePriceData;
use futures::future::try_join_all;
use serde::Deserialize;
use sqlx::FromRow;
use std::sync::Arc;
use tokio::{fs::*, io::AsyncWriteExt, sync::Mutex, time::*};

#[derive(Clone, Debug)]
pub struct LrData {
    pub lr_value: f64,  // linear regression value
    pub close_time: i64,
}
impl LrData {
    fn new() -> LrData {
        let a = LrData {
            lr_value: 0.0,
            close_time: 0,
        };
        a
    }
}

// Binance MA (closeprice)
pub async fn linear_regression(
    length: usize,
    offset: usize,
    input_rt_data: &HashMap<String, Vec<RealtimePriceData>>,
    filtered_symbols: &HashMap<String, FilteredDataValue>,
) -> Result<HashMap<String, Vec<LrData>>, Box<dyn std::error::Error + Send + Sync>> {
    if filtered_symbols.is_empty() {
        Err("Err")?;
    }

    let mut lr_data_wrapper: HashMap<String, Vec<LrData>> = HashMap::new();
    let mut lr_data_wrapper_arc = Arc::new(Mutex::new(lr_data_wrapper));

    let mut task_vec = Vec::new();
    for (symbol, filtered_data) in filtered_symbols {
        if let Some(vec) = input_rt_data.get(symbol) {
            let lr_data_wrapper_arc_c = Arc::clone(&lr_data_wrapper_arc);
            let symbol_c = symbol.clone();
            
            if vec.len() >= length {
                let rt_price_data = vec.clone();
                task_vec.push(tokio::spawn(async move {
                    // Calculate prediction of linear regression
                    let mut lr_data_vec: Vec<LrData> = Vec::new();
                    
                    for window in rt_price_data.windows(length) {
                        let mut lr_data = LrData::new();
                        let x: Vec<f64> = (0..length).map(|x| x as f64).collect();
                        let y: Vec<f64> = window.iter().map(|x| x.close_price).collect();
                
                        let x_mean: f64 = x.iter().sum::<f64>() / x.len() as f64;
                        let y_mean: f64 = y.iter().sum::<f64>() / y.len() as f64;
                
                        let numerator: f64 = x.iter().zip(y.iter()).map(|(x_i, y_i)| (x_i - x_mean) * (y_i - y_mean)).sum();
                        let denominator: f64 = x.iter().map(|x_i| (x_i - x_mean).powi(2)).sum();
                
                        let slope = numerator / denominator;
                        let intercept = y_mean - slope * x_mean;
                
                        let linreg = intercept + slope * (length as f64 - 1.0 - offset as f64);
                        lr_data.lr_value = linreg;
                        lr_data.close_time = window.last().unwrap().close_time;
                        lr_data_vec.push(lr_data.clone());
                    }
                    let mut lr_data_wrapper_lock = lr_data_wrapper_arc_c.lock().await;
                    lr_data_wrapper_lock.insert(symbol_c, lr_data_vec.clone());
                }));
            }
        }
    }
    try_join_all(task_vec).await?;
    let a = lr_data_wrapper_arc.lock().await.to_owned();
    Ok(a)
}