use textsender_models::config::auxiliary::TwilioConfig;
use textsender_models::contact::Contact;
use textsender_models::message::Message;

pub async fn send_messages(
    config: &TwilioConfig,
    contacts: &Vec<Contact>,
    message: &Message,
    second_interval: u64,
) {
    let long_sleep_limit: i64 = 5;
    let mut count: i64 = 0;

    for contact in contacts {
        println!("Sending to: {:?}", contact.phone_number);
        let param = swoosh::twilio::types::Parameters {
            schedule: false,
            schedule_at: None,
        };
        match swoosh::twilio::api::send_mssage(message, contact, param, config).await {
            Ok(response) => {
                println!("Raw response: {response:?}");
                let val = swoosh::twilio::api::response_to_json(response).await;
                println!("Response: {val:?}");
            }
            Err(err) => {
                eprintln!("Error: {err:?}");
            }
        }

        if count % long_sleep_limit == 0 {
            // Sleep for X seconds
            let wait_time = second_interval;
            std::thread::sleep(std::time::Duration::from_secs(wait_time));
        } else {
            // Sleep for a second
            std::thread::sleep(std::time::Duration::from_secs(1));
        }

        count += 1;
    }
}

pub fn parse_numbers(filepath: &str) -> Result<Vec<Contact>, std::io::Error> {
    match std::fs::File::open(filepath) {
        Ok(file) => {
            let reader = std::io::BufReader::new(file);
            let contacts: Vec<Contact> = match serde_json::from_reader(reader) {
                Ok(va) => va,
                Err(err) => {
                    return Err(std::io::Error::other(err.to_string()));
                }
            };

            Ok(contacts)
        }
        Err(err) => Err(err),
    }
}

pub fn parse_message(filepath: &str) -> Result<Message, std::io::Error> {
    match std::fs::File::open(filepath) {
        Ok(file) => {
            let reader = std::io::BufReader::new(file);
            let message: Message = serde_json::from_reader(reader)?;
            Ok(message)
        }
        Err(err) => Err(err),
    }
}

#[cfg(test)]
mod tests {
    #[test]
    fn test_parse_message() {
        let message_path = String::from("tests/message-0.json");
        match super::parse_message(&message_path) {
            Ok(message) => {
                assert_eq!(false, message.content.is_empty(), "Content is empty");
            }
            Err(err) => {
                assert!(false, "Error: {err:?}");
            }
        };
    }

    #[test]
    fn test_parse_numbers() {
        let numbers_path = String::from("tests/numbers-0.json");
        match super::parse_numbers(&numbers_path) {
            Ok(contacts) => {
                assert_eq!(false, contacts.is_empty(), "Should not be empty");
            }
            Err(err) => {
                assert!(false, "Error: {err:?}");
            }
        };
    }
}