pub async fn get_rating_competition(
    degree: &str,
    program_id: &str,
    case_number: &str,
) -> Result<Option<Competition>, Box<dyn std::error::Error>> {
    let rating_response: RatingResponse = reqwest::get(format!(
        "{API_PREFIX}/{API_KEY}/rating/{degree}/budget?program_id={program_id}"
    ))
    .await?
    .json()
    .await?;

    match find_score(rating_response, case_number) {
        None => Err(Box::from("no matching competition")),
        competition => Ok(competition),
    }
}

fn find_score(response: RatingResponse, case_number: &str) -> Option<Competition> {
    if !response.ok {
        return None;
    }

    response
        .result
        .general_competition
        .iter()
        .find(|c| -> bool {
            if let Some(c) = &c.case_number {
                c == case_number
            } else {
                false
            }
        })
        .cloned()
}

pub struct Response<T> {
    pub ok: bool,
    pub message: String,
    pub result: T,
}

pub type RatingResponse = Response<RatingResult>;

pub struct RatingResult {
    pub general_competition: Vec<Competition>,
}

pub struct Competition {
    pub position: i32,
    pub priority: i32,
    pub total_scores: f64,
    pub case_number: Option<String>,
    pub exam_scores: Option<f64>,
}

async fn get_updates(offset: i32) -> Result<GetUpdatesResponse, Box<dyn std::error::Error>> {
    let params = [("offset", &offset.to_string())];
    let url =
        reqwest::Url::parse_with_params(&format!("{TG_API_PREFIX}{TOKEN}/getUpdates"), &params)?;

    let response = reqwest::get(url).await?;
    if !response.status().is_success() {
        let error: ErrorResponse = response.json().await?;
        let text = format!(
            "cannot get updates\nerror: `{}`",
            error.description.unwrap_or_default()
        );
        send_message(&text, LOGS_CHAT_ID).await?;
        return Err(Box::from("cannot get updates"));
    }

    Ok(response.json().await?)
}

pub async fn handle_updates(db: &DB, offset: i32) -> Result<i32, Box<dyn std::error::Error>> {
    let data = get_updates(offset).await?;

    let mut max_update_id = 0;
    for update in data.result {
        if update.update_id > max_update_id {
            max_update_id = update.update_id;
        }

        if let Some(message) = update.message {
            if let Some(text) = message.text {
                let chat_id = message.from.id.to_string();
                match MessageRequest::from(text) {
                    Some(request) => handle_message_request(db, request, &chat_id).await?,
                    None => send_message(messages::unknown_message, &chat_id).await?,
                }
            }
        }
    }

    Ok(max_update_id + 1)
}

impl MessageRequest {
    pub fn from(text: String) -> Option<Self> {
        let text: Vec<String> = text.split(' ').map(|w| w.to_string()).collect();
        if text.is_empty() {
            return None;
        }

        let command = text[0].as_str();
        match command {
            "/watch" | "/unwatch" => {
                let incorrect_command = Some(Self::IncorrectCommand(command.to_string()));

                if text.len() < 5 {
                    if text.len() == 2 && text[1] == "all" {
                        return Some(Self::UnwatchAll);
                    }
                    return incorrect_command;
                }

                // waiting for let-chain
                if let Some(watch) = Watch::new("itmo", &text[2], &text[3], &text[4]) {
                    if watch.degree == Degree::Master {
                        return match command {
                            "/watch" => Some(Self::Watch(watch)),
                            "/unwatch" => Some(Self::Unwatch(watch)),
                            _ => incorrect_command,
                        };
                    }
                }

                incorrect_command
            }
            "/about" => Some(Self::About),
            "/help" => Some(Self::Help),
            "/start" => Some(Self::Start),
            _ => None,
        }
    }
}

pub enum Degree {
    Bachelor,
    Master,
    Postgraduate,
}

pub struct Watch {
    pub uni: String,
    pub degree: Degree,
    pub program_id: String,
    pub case_number: String,
}

pub enum MessageRequest {
    About,
    Help,
    Start,
    Unwatch(Watch),
    UnwatchAll,
    Watch(Watch),
    IncorrectCommand(String),
}

async fn handle_message_request(
    db: &DB,
    request: MessageRequest,
    chat_id: &str,
) -> Result<(), CrateError> {
    match request {
        MessageRequest::Watch(args) => {
            let result = handle_competition(db, chat_id, &args.degree.to_string(), &args.case_number, &args.program_id, true).await;
            if let Err(_) = result {
                send_message(messages::rating_not_found, chat_id).await?;
            }
        }
        MessageRequest::Unwatch(args) => {
            db.delete_competition(
                &args.case_number,
                chat_id,
                &args.program_id,
                &args.degree.to_string(),
            )?;
            send_message(messages::done, chat_id).await?;
        }
        MessageRequest::UnwatchAll => {
            db.delete_competition_by_user(chat_id)?;
            send_message(messages::done, chat_id).await?;
        }
        MessageRequest::IncorrectCommand(command) => {
            send_incorrect_command_message(&command, chat_id).await?
        }
        MessageRequest::Help => send_message(messages::help, chat_id).await?,
        MessageRequest::Start => send_message(messages::start, chat_id).await?,
        MessageRequest::About => send_message(messages::about, chat_id).await?,
    };
    Ok(())
}

pub async fn handle_competition(
    db: &DB,
    chat_id: &str,
    degree: &str,
    case_number: &str,
    program_id: &str,
    is_user_request: bool,
) -> Result<(), Box<dyn std::error::Error>> {
    let competition = get_rating_competition(db, degree, program_id, case_number).await?;

    match db.select_competition(chat_id, case_number, degree, program_id) {
        Ok(old_competition) => {
            if let Some(competition) = competition {
                let program = db.select_program("itmo", program_id)?;
                let program_name = if let Some(program) = program {
                    program.title_ru
                } else {
                    "Названия нет".to_string()
                };

                let mut should_send_message = false;

                // update if competition is old (competition != old_competition)
                // insert if is new (when old == None, on first user request)
                if let Some(old_competition) = old_competition {
                    if competition != old_competition {
                        db.update_competition(&competition, chat_id, program_id, degree)?;
                        should_send_message = true;
                    }
                } else {
                    db.insert_competition(&competition, chat_id, program_id, degree)?;
                }

                // send if it's user request or record in db was updated
                if is_user_request || should_send_message {
                    send_competition_message(&competition, chat_id, &program_name).await?;
                }
            }
        }
        Err(e) => {
            eprintln!("cannot select competition: {e}")
        }
    };
    Ok(())
}

pub async fn send_message(text: &str, chat_id: &str) -> Result<(), Box<dyn std::error::Error>> {
    let text = &text.replace('-', "\\-").replace('.', "\\.");

    let params = [
        ("chat_id", chat_id),
        ("text", text),
        ("parse_mode", "MarkdownV2"),
    ];

    let url =
        reqwest::Url::parse_with_params(&format!("{TG_API_PREFIX}{TOKEN}/sendMessage"), &params)?;
    let response = reqwest::get(url).await?;
    if !response.status().is_success() {
        let error: ErrorResponse = response.json().await?;
        let msg = "Cannot send message request";
        if let Some(description) = error.description {
            eprintln!("{msg}: {description}");
        }
        return Err(Box::from(msg));
    }

    let data: SendMessageResponse = response.json().await?;

    if !data.ok {
        eprintln!(
            "Cannot send message: {}",
            data.description
                .unwrap_or_else(|| "error has no description".to_string())
        )
    }

    Ok(())
}

const TEN_MIN_IN_SEC: i32 = 10 * 60;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let db = init_db()?;

    load_programs(&db).await.unwrap();

    let mut offset = 0;
    let mut sec_counter = 0;
    loop {
        offset = handle_updates(&db, offset).await.unwrap();

        if sec_counter == 0 {
            check_rating_updates(&db).await?;
        }
        sec_counter = (sec_counter + 1) % TEN_MIN_IN_SEC;

        time::sleep(time::Duration::from_secs(1)).await;
    }
}

async fn check_rating_updates(db: &DB) -> Result<(), Box<dyn std::error::Error>> {
    // select registered watchers from 'results'
    for c in db.select_all_competitions()? {
        if let Some(case_number) = c.competition.case_number {
            handle_competition(db, &c.tg_chat_id, &c.degree, &case_number, &c.program_id, false)
            .await?;
        }
    }
    Ok(())
}