#![feature(try_trait)]
#![feature(async_closure)]
use indeed_querybuilder::IndeedQuery;
use reqwest;
use scraper::{Html, Selector};
use std::collections::HashMap;
use url::Url;

pub type JobMap = HashMap<Company, Vec<Job>>;
pub type CompanyMap = HashMap<String, Company>;
pub type ScrapeResult = std::result::Result<JobMap, ScrapeError>;

#[derive(Debug, Clone, PartialEq, Hash, Eq, Default)]
pub struct Company {
    name: String,
    homepage: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Hash, Eq, Default)]
pub struct Job {
    job_title: String,
    location: String,
    job_description: Option<String>,
    url: String,
}

#[derive(Debug, Clone, PartialEq)]
pub enum Salary {
    AnnualFixed(u32),
    AnnualRange(u32, u32),
    HourlyFixed(f32),
    HourlyRange(f32),
}

#[derive(Debug, Clone)]
pub enum ScrapeError {
    CantFindHost,
    InvalidUrl,
    ParsingFailure,
    RequestFailure,
    NoElementFound,
}
impl From<std::num::ParseIntError> for ScrapeError {
    fn from(_err: std::num::ParseIntError) -> Self {
        Self::ParsingFailure
    }
}
impl From<reqwest::Error> for ScrapeError {
    fn from(err: reqwest::Error) -> Self {
        if err.is_timeout() {
            Self::CantFindHost
        } else if err.is_decode() {
            Self::ParsingFailure
        } else {
            Self::RequestFailure
        }
    }
}
impl From<std::option::NoneError> for ScrapeError {
    fn from(_err: std::option::NoneError) -> Self {
        ScrapeError::NoElementFound
    }
}
impl From<url::ParseError> for ScrapeError {
    fn from(_err: url::ParseError) -> Self {
        ScrapeError::InvalidUrl
    }
}

#[tokio::main(core_threads = 10)]
pub async fn scrape(query: IndeedQuery) -> ScrapeResult {
    let mut q = query.to_owned();

    let url = query.build_url()?;
    println!("First Page: {}", url.as_str());
    let job_count = parse_job_count(&url).await?;

    let mut urls = vec![];
    while q.start < job_count {
        urls.push(q.build_url()?);
        q.increment_page();
    }

    let mut companies = CompanyMap::new();
    //let data = Arc::new(Mutex::new(JobMap::new()));
    let mut map = JobMap::new();

    let client = reqwest::Client::new();
    for url in urls {
        println!("Running task search_page: {}", url);
        let res = client.get(&url).send().await?.text().await?;
        let page = Html::parse_document(&res);
        let jobs = parse_jobs(page, &mut companies).await?;
        //let mut map = data.lock().unwrap();
        map.extend(jobs);
    }

    //let map: JobMap = data.lock().unwrap().clone();
    Ok(map)
}

async fn parse_job_count(search_page: &str) -> Result<u32, ScrapeError> {
    let body = reqwest::get(search_page).await?.text().await?;
    let selector = Selector::parse("#searchCountPages").unwrap();
    let html = Html::parse_document(&body);
    let el = html.select(&selector).next()?.inner_html().replace(",", "");
    let split: Vec<&str> = el.split(" ").collect();
    let job_count = split[split.len() - 2].parse::<u32>()?;
    println!("Job Count {}", job_count);
    Ok(job_count)
}

async fn parse_jobs(search_page: Html, companies: &mut CompanyMap) -> ScrapeResult {
    let mut map = JobMap::new();
    let selector = Selector::parse(".jobsearch-SerpJobCard").unwrap();
    for job_el in search_page.select(&selector) {
        let frag: &Html = &Html::parse_fragment(&job_el.html());
        let company = parse_company(&frag, companies).await?;
        let job = parse_job(&frag).await?;
        if map.contains_key(&company) {
            map.get_mut(&company)
                .expect("Could not find company")
                .push(job);
        } else {
            map.insert(company, vec![job]);
        }
    }
    println!("All Jobs on page Parsed!");
    Ok(map)
}

async fn parse_job(html: &Html) -> Result<Job, ScrapeError> {
    let job_title_sel = Selector::parse(".jobtitle").unwrap();
    let el = html.select(&job_title_sel).next()?;
    let job_title = el.value().attr("title")?.to_string();
    let href = el.value().attr("href")?;

    let location_sel = Selector::parse(".location").unwrap();
    let location = html
        .select(&location_sel)
        .next()?
        .text()
        .collect::<Vec<_>>()[0]
        .to_string();

    let mut job = Job {
        job_title,
        location,
        ..Job::default()
    };

    let base_url: Url = Url::parse("https://www.indeed.com").unwrap();

    if let Ok(url) = base_url.join(&href) {
        let job_detail_page = reqwest::get(url.as_str()).await?.text().await?;
        let job_description = parse_job_description(&Html::parse_document(&job_detail_page)).await;
        job = Job {
            job_description,
            url: url.to_string(),
            ..job
        };
    }

    println!("Parsed Job: {}", job.job_title);
    Ok(job)
}

async fn parse_job_description(html: &Html) -> Option<String> {
    let selector = Selector::parse("#jobDescriptionText").unwrap();
    let el = html.select(&selector).next();
    match el {
        Some(e) => Some(e.text().collect::<Vec<&str>>().join("\n")),
        None => None,
    }
}

async fn parse_company(job_html: &Html, map: &mut CompanyMap) -> Result<Company, ScrapeError> {
    let company_page_sel = Selector::parse(".company").unwrap();
    let company_name_el = job_html.select(&company_page_sel).next()?;

    let name = company_name_el
        .text()
        .collect::<Vec<&str>>()
        .join("")
        .to_string()
        .replace("\n", "");

    match map.get_mut(&name) {
        Some(c) => Ok(c.clone()),
        None => {
            let mut company = Company {
                name: name.clone(),
                ..Company::default()
            };

            let detail_sel = Selector::parse("a").unwrap();
            let company_detail_url = company_name_el.select(&detail_sel).next();
            if let Some(cd) = company_detail_url {
                let mut href: String = cd.value().attr("href").unwrap().to_owned();
                href.push('/');
                let base_url: Url = Url::parse("https://www.indeed.com").unwrap();

                if let Ok(url) = base_url.join(&href) {
                    let url = url.join("about/")?;
                    let res = reqwest::get(url.as_str()).await?.text().await?;
                    let detail_section_sel = Selector::parse(".cmp-CompanyDetailSection").unwrap();
                    let content_sel = Selector::parse(".cmp-CompanyDetailSection-content").unwrap();
                    let link_sel = Selector::parse("a").unwrap();
                    let company_detail_html = Html::parse_document(&res);
                    let sections = company_detail_html.select(&detail_section_sel).last();
                    if let Some(s) = sections {
                        let homepage_el = s.select(&content_sel).next()?.select(&link_sel).next();

                        if let Some(hp_el) = homepage_el {
                            let homepage = Some(hp_el.value().attr("href")?.to_string());
                            company = Company {
                                homepage,
                                ..company
                            };
                        }
                    }
                }
            }

            println!("Parsed company: {}", company.name);
            map.insert(name, company.clone());
            Ok(company)
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use indeed_querybuilder::*;

    #[test]
    fn test_parse() {
        let query = IndeedQueryBuilder::default()
            .city(City::CityState(
                "San Francisco".to_string(),
                "CA".to_string(),
            ))
            .company("Apple".to_string())
            .radius(100 as u32)
            .build()
            .unwrap();
        scrape(query);
    }
}