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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

use std::fmt::Display;

use serde::{Deserialize, Serialize};
use tabled::{
    builder::Builder,
    settings::{style::Style, themes::ColumnNames},
};

use crate::config::global::glob_user_config;

#[derive(Default, Deserialize, Serialize, Debug)]
pub struct SubmissionList {
    #[serde(default, alias = "lastKey")]
    pub(crate) last_key: Option<String>,
    #[serde(default, alias = "hasNext")]
    pub(crate) has_next: bool,
    #[serde(default)]
    pub(crate) submissions: Vec<list_nest::Submission>,
}

impl Display for SubmissionList {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        if self.submissions.is_empty() {
            return "No information".fmt(f);
        }
        let user = glob_user_config();

        let mut subs = vec![];
        let mut temp = Vec::with_capacity(
            user.column
                .min(self.submissions.len()),
        );

        for i in 0..user
            .column
            .min(self.submissions.len())
        {
            temp.push(i.to_string());
        }

        subs.push(temp.clone());
        temp.clear();

        for submission in &self.submissions {
            temp.push(submission.to_string());
            if temp.len() >= user.column {
                subs.push(temp.clone());
                temp.clear();
            }
        }
        if !temp.is_empty() {
            subs.push(temp.clone());
        }

        let mut table = Builder::from(subs).build();
        table
            .with(Style::modern())
            .with(ColumnNames::default());

        format!("{}", table).fmt(f)
    }
}

pub mod list_nest {
    use std::fmt::Display;

    use serde::{Deserialize, Serialize};

    #[derive(Deserialize, Serialize, Debug)]
    pub struct Submission {
        #[serde(default)]
        pub id: String,
        #[serde(default)]
        pub title: String,
        #[serde(default)]
        pub status: Option<String>,
        #[serde(default, alias = "statusDisplay")]
        pub status_display: Option<String>,
        #[serde(default)]
        pub lang: String,
        #[serde(default, alias = "langName")]
        pub lang_name: String,
        #[serde(default)]
        pub runtime: String,
        #[serde(default)]
        pub timestamp: String,
        #[serde(default)]
        pub url: String,
        #[serde(default, alias = "isPending")]
        pub is_pending: String,
        #[serde(default)]
        pub memory: String,
        #[serde(default, alias = "submissionComment")]
        pub submission_comment: Option<String>,
    }

    impl Display for Submission {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            format!(
                "• Title: {title} \n\
                • ID: {id} \n\
                • Lang: {lang} \n\
                • Status: {status} \n\
                • Runtime: {tim} \n\
                • Memory: {mem} \n\
                • Comment: {cmt} \n\
                ",
                cmt = self
                    .submission_comment
                    .as_deref()
                    .unwrap_or_default(),
                id = self.id,
                title = self.title,
                lang = self.lang_name,
                status = self
                    .status_display
                    .as_deref()
                    .unwrap_or_default(),
                tim = self.runtime,
                mem = self.memory,
            )
            .fmt(f)
        }
    }
}