1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

pub mod chromium;
pub mod firefox;

use std::fmt::Display;

use miette::Result;
use serde::{Deserialize, Serialize};

#[derive(Clone, Copy)]
#[derive(PartialEq, Eq)]
#[derive(Default)]
#[derive(Debug)]
pub enum Browser {
    Edge      = 0,
    Chrome    = 1,
    #[default]
    Firefox   = 2,
    Librewolf = 3,
}

impl Display for Browser {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Edge => "edge",
            Self::Chrome => "chrome",
            Self::Firefox => "firefox",
            Self::Librewolf => "librewolf",
        }
        .fmt(f)
    }
}

impl From<&str> for Browser {
    fn from(value: &str) -> Self {
        match value {
            "edge" => Self::Edge,
            "chrome" => Self::Chrome,
            "firefox" => Self::Firefox,
            "librewolf" => Self::Librewolf,
            _ => Self::Firefox,
        }
    }
}

#[derive(Default, Clone)]
#[derive(Serialize, Deserialize)]
#[derive(Debug)]
#[derive(PartialEq, Eq)]
pub struct Cookies {
    pub csrf:    String,
    pub session: String,
}

impl Cookies {
    pub fn is_completion(&self) -> bool {
        !(self.csrf.is_empty() || self.session.is_empty())
    }
}

impl Display for Cookies {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        format!("LEETCODE_SESSION={};csrftoken={};", self.session, self.csrf).fmt(f)
    }
}
/// get csrf and session
///
/// * `borwser`: firefox, librewolf, edge, chrome
pub async fn get_cookie<T>(borwser: T, host: &str) -> Result<Cookies>
where
    T: Into<Browser>,
{
    let res = match borwser.into() {
        Browser::Firefox => firefox::get_session_csrf(Browser::Firefox, host).await?,
        Browser::Librewolf => firefox::get_session_csrf(Browser::Librewolf, host).await?,
        Browser::Edge => chromium::get_session_csrf(Browser::Edge, host).await?,
        Browser::Chrome => chromium::get_session_csrf(Browser::Chrome, host).await?,
    };

    Ok(res)
}