Slow Stochastic Oscillator

use centaur_technical_indicators::momentum_indicators::bulk::{slow_stochastic, stochastic_oscillator};
use centaur_technical_indicators::ConstantModelType;
use centaur_technical_indicators::chart_trends::{peaks, valleys};
use std::time::Instant;

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 close = vec![...];  // closing prices

    let indicator_loop = Instant::now();

        // get buy and sell points, in an ideal world we would buy at the lowest point in the dip and sell at the highest point in the peak
        // In the course of a 20-day period (1 month of trading days), we want to find the highest peak and lowest valley within 5 days of each other
        let sell_points = peaks(&close, 20, 5).into_iter().map(|(_, i)| i).collect::<Vec<usize>>();
        let buy_points = valleys(&close, 20, 5).into_iter().map(|(_, i)| i).collect::<Vec<usize>>();

        // Define the ranges for optimization
        let max_period = 20;
        let min_period = 2;
        let min_oversold = 0;
        let max_oversold = 50;
        let min_overbought = 50;
        let max_overbought = 100;

        let fuzz_parameter = 5; // Allowable distance from buy/sell points

        // Store the best parameters found
        let mut best_rating = 0.0;
        let mut best_period = 0;
        let mut best_model = ConstantModelType::SimpleMovingAverage;
        let mut best_oversold = 0;
        let mut best_overbought = 0;
        let mut best_indicators = vec![];

        // Optimized SO
        let optimized_so = stochastic_oscillator(&close, 13);

        for oversold in min_oversold..=max_oversold {
            for overbought in min_overbought..=max_overbought {
                for &ma_type in &[ConstantModelType::SimpleMovingAverage, ConstantModelType::ExponentialMovingAverage, ConstantModelType::SmoothedMovingAverage] {
                    for period in min_period..=max_period {
                        let indicators = slow_stochastic(&optimized_so, ma_type, period);
                        let mut rating = vec![];
                        let mut matched_sell = vec![];
                        let mut matched_buy = vec![];
                        for i in 0..indicators.len() {
                            let price_location = i + period;
                            if indicators[i] > overbought as f64 {
                                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_location in (price_location - fuzz_parameter)..=(price_location + fuzz_parameter) {
                                        // It's ok if we count multiple times for fuzzed locations as we reduce the rating
                                        // based off of distance from the actual sell point which will impact the final rating
                                        if sell_points.contains(&fuzzed_location) {
                                            rating.push(proximity_rating(&fuzzed_location, &price_location));
                                            matched_sell.push(fuzzed_location);
                                            found_sell = true;
                                        }
                                        if buy_points.contains(&fuzzed_location) {
                                            // Note the `-` here to penalize for selling instead of buying
                                            if !matched_sell.contains(&fuzzed_location) {
                                                rating.push(-proximity_rating(&fuzzed_location, &price_location));
                                            }
                                        }
                                    }
                                    if !found_sell {
                                        rating.push(0.0);
                                    }
                                }
                            } else if indicators[i] < oversold as f64 {
                                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_location in (price_location - fuzz_parameter)..=(price_location + fuzz_parameter) {
                                        // It's ok if we count multiple times for fuzzed locations as we reduce the rating
                                        // based off of distance from the actual sell point which will impact the final rating
                                        if buy_points.contains(&fuzzed_location) {
                                            rating.push(proximity_rating(&fuzzed_location, &price_location));
                                            matched_buy.push(fuzzed_location);
                                            found_buy = true;
                                        }
                                        if sell_points.contains(&fuzzed_location) {
                                            // Note the `-` here to penalize for buying instead of selling
                                            if !matched_buy.contains(&fuzzed_location) {
                                                rating.push(-proximity_rating(&fuzzed_location, &price_location));
                                            }
                                        }
                                    }
                                    if !found_buy {
                                        rating.push(0.0);
                                    }
                                }
                            }
                        }
                        // Look for any missed buy/sell points and penalize
                        for missed_sell in sell_points.iter() {
                            if !matched_sell.contains(missed_sell) {
                                rating.push(-1.0);
                            }
                        }
                        for missed_buy in buy_points.iter() {
                            if !matched_buy.contains(missed_buy) {
                                rating.push(-1.0);
                            }
                        }
                        let total_rating: f64 = rating.iter().sum::<f64>() / (rating.len() as f64);
                        if total_rating > best_rating {
                            best_rating = total_rating;
                            best_period = period;
                            best_model = ma_type;
                            best_oversold = oversold;
                            best_overbought = overbought;
                            best_indicators = indicators.clone();
                        }
                    }
                }
            }
        }

        println!(
            "Indicators optimization loop took {} ms to run",
            indicator_loop.elapsed().as_millis()
        );

        println!("
Best Slow Stochastic parameters found:");
        println!("Period: {}", best_period);
        println!("Model: {:?}", best_model);
        println!("Oversold threshold: {}", best_oversold);
        println!("Overbought threshold: {}", best_overbought);
        println!("Rating: {}", best_rating);
        println!("Best Slow Stochastic values: {:?}", best_indicators);
}