Ichimoku Cloud

use centaur_technical_indicators::candle_indicators::bulk::ichimoku_cloud;
use centaur_technical_indicators::chart_trends::{peaks, valleys};

fn proximity_rating(fuzzed_location: &usize, price_location: &usize) -> f64 {
    1.0 / (*fuzzed_location as f64 - *price_location as f64).abs()
}

pub fn main() {
    // fetch the data in your preferred way
    // let high = vec![...];
    // let low = vec![...];
    // let close = vec![...];

    let sell_points = peaks(&close, 20, 5)
        .expect("Failed to calculate peaks")
        .into_iter()
        .map(|(_, i)| i)
        .collect::<Vec<usize>>();
    let buy_points = valleys(&close, 20, 5)
        .expect("Failed to calculate valleys")
        .into_iter()
        .map(|(_, i)| i)
        .collect::<Vec<usize>>();

    let fuzz_parameter = 5;
    let mut best_rating = f64::NEG_INFINITY;
    let mut best_conversion_period = 0;
    let mut best_base_period = 0;
    let mut best_span_b_period = 0;
    let mut best_indicators = vec![];

    for conversion_period in 2..=30_usize {
        for base_period in 2..=60_usize {
            if base_period <= conversion_period { continue; }
            for span_b_period in 2..=120_usize {
                if span_b_period <= base_period { continue; }
                if close.len() < span_b_period + 1 { continue; }

                let indicators = ichimoku_cloud(&high, &low, &close, conversion_period, base_period, span_b_period)
                    .expect("Failed to calculate Ichimoku Cloud");

                let mut rating = vec![];
                let mut matched_sell = vec![];
                let mut matched_buy = vec![];

                for i in 1..indicators.len() {
                    let price_location = i + base_period - 1;
                    if price_location >= close.len() { break; }

                    // Each tuple: (conversion_line/tenkan, base_line/kijun, span_a, span_b, chikou)
                    let (tenkan, kijun, _, _, _) = indicators[i];
                    let (prev_tenkan, prev_kijun, _, _, _) = indicators[i - 1];

                    if tenkan < kijun && prev_tenkan >= prev_kijun {
                        // Bearish crossover: Tenkan crosses below Kijun
                        if sell_points.contains(&price_location) {
                            rating.push(1.0);
                            matched_sell.push(price_location);
                        } else if buy_points.contains(&price_location) {
                            rating.push(-1.0);
                        } else {
                            let mut found_sell = false;
                            for fuzzed in price_location.saturating_sub(fuzz_parameter)..=price_location + fuzz_parameter {
                                if sell_points.contains(&fuzzed) {
                                    rating.push(proximity_rating(&fuzzed, &price_location));
                                    matched_sell.push(fuzzed);
                                    found_sell = true;
                                }
                                if buy_points.contains(&fuzzed) && !matched_sell.contains(&fuzzed) {
                                    rating.push(-proximity_rating(&fuzzed, &price_location));
                                }
                            }
                            if !found_sell { rating.push(0.0); }
                        }
                    } else if tenkan > kijun && prev_tenkan <= prev_kijun {
                        // Bullish crossover: Tenkan crosses above Kijun
                        if buy_points.contains(&price_location) {
                            rating.push(1.0);
                            matched_buy.push(price_location);
                        } else if sell_points.contains(&price_location) {
                            rating.push(-1.0);
                        } else {
                            let mut found_buy = false;
                            for fuzzed in price_location.saturating_sub(fuzz_parameter)..=price_location + fuzz_parameter {
                                if buy_points.contains(&fuzzed) {
                                    rating.push(proximity_rating(&fuzzed, &price_location));
                                    matched_buy.push(fuzzed);
                                    found_buy = true;
                                }
                                if sell_points.contains(&fuzzed) && !matched_buy.contains(&fuzzed) {
                                    rating.push(-proximity_rating(&fuzzed, &price_location));
                                }
                            }
                            if !found_buy { rating.push(0.0); }
                        }
                    }
                }

                for missed in sell_points.iter() { if !matched_sell.contains(missed) { rating.push(-1.0); } }
                for missed in buy_points.iter()  { if !matched_buy.contains(missed)  { rating.push(-1.0); } }

                if !rating.is_empty() {
                    let total: f64 = rating.iter().sum::<f64>() / rating.len() as f64;
                    if total > best_rating {
                        best_rating = total;
                        best_conversion_period = conversion_period;
                        best_base_period = base_period;
                        best_span_b_period = span_b_period;
                        best_indicators = indicators.clone();
                    }
                }
            }
        }
    }

    println!("Best conversion_period: {}", best_conversion_period);
    println!("Best base_period: {}", best_base_period);
    println!("Best span_b_period: {}", best_span_b_period);
    println!("Rating: {:.4}", best_rating);
}