#![feature(slice_pattern)]

pub mod utils;

use core::slice::SlicePattern;
use curl::easy::Easy;
use std::env::var;
use std::io::Read;
use std::str::from_utf8;
use std::{error::Error, net::SocketAddr};
use utils::QueryParameters;
use warp::{http::Method, hyper::body::Bytes, path::FullPath, Filter};

const BASE: &str = "https://www.bankofmaldives.com.mv/internetbanking/api/";
const ERR: &str = "{ code: 407, message: \"Proxy failed\" }";

fn get_base_url() -> String {
    match var("BML_PROXY_BASE") {
        Ok(base) => base,
        Err(_) => BASE.to_string(),
    }
}

fn get_proxied_body(
    uri: &String,
    method: &Method,
    body: &Bytes,
    base: &String,
) -> Result<String, Box<dyn Error>> {
    let mut handle = Easy::new();
    handle.url(format!("{}{}", base, uri).as_str())?;

    if method == Method::POST {
        handle.post(true)?;
        handle.post_field_size(body.len() as u64)?;
    }

    let mut buf = Vec::new();
    {
        let mut transfer = handle.transfer();

        if method == Method::POST {
            transfer.read_function(|into| {
                let read = body.as_slice().read(into).unwrap_or(0);
                Ok(read)
            })?;
        }

        transfer.write_function(|data| {
            buf.extend_from_slice(data);
            Ok(data.len())
        })?;

        transfer.perform()?;
    }

    let cloned_buf = buf.clone();
    let s = from_utf8(&cloned_buf)?;

    Ok(s.to_string())
}

fn handler(
    uri: FullPath,
    _: QueryParameters,
    method: Method,
    body: Bytes,
    ip: Option<SocketAddr>,
    base: String,
) -> String {
    let uri = uri.as_str().clone().to_string();
    let ip_str = match ip {
        Some(v) => format!("{}", v),
        None => "unknown".to_string(),
    };

    println!("({}) {}", ip_str, uri);

    let proxy_response = get_proxied_body(&uri, &method, &body, &base);

    let res = match proxy_response {
        Ok(v) => v,
        Err(e) => {
            println!("error: {}", e);
            ERR.to_string()
        }
    };

    return res;
}

#[tokio::main]
async fn main() {
    let proxy_handler = warp::any()
        .and(utils::extract_request_data_filter())
        .and(warp::filters::addr::remote())
        .and(warp::any().map(move || get_base_url()))
        .map(handler);

    let log_warning = || {
        println!("This binary is meant to be used with LD_PRELOAD=\"/path/to/libcurl-impersonate-chrome.so\"");
        println!("If you're on Arch Linux, this library can be obtained via the AUR package 'libcurl-impersonate-bin'");
        println!(
            "A common location for this library is '/usr/local/lib/libcurl-impersonate-chrome.so'"
        );
        println!("\n[WARN] proceeding without libcurl-impersonate, expect cloudflare blockages\n");
    };

    match var("LD_PRELOAD") {
        Ok(v) => {
            if !v.contains("libcurl-impersonate-chrome.so") {
                log_warning();
            }
        }

        Err(_) => log_warning(),
    }

    let port = var("BML_PROXY_PORT")
        .unwrap_or_default()
        .parse::<u16>()
        .unwrap_or(3030);

    println!("Proxy running on port: {}", port);
    println!("Proxy base URL: {}", get_base_url());
    println!("Available environment variables for modification: BML_PROXY_PORT, BML_PROXY_BASE\n");

    warp::serve(proxy_handler).run(([0, 0, 0, 0], port)).await;
}
