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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183

use serde::{Deserialize, Serialize};

#[derive(Default, Deserialize, Serialize, Debug, Clone, PartialEq, Eq)]
pub struct TestInfo {
    #[serde(default)]
    interpret_id:          String,
    #[serde(default)]
    test_case:             String,
    #[serde(default)]
    interpret_expected_id: String,
}

impl TestInfo {
    pub fn interpret_id(&self) -> &str {
        &self.interpret_id
    }
}

#[derive(Deserialize, Serialize, Default, Debug, Clone, Copy, PartialEq, Eq)]
pub struct SubmitInfo {
    #[serde(default)]
    submission_id: u32,
}

impl SubmitInfo {
    #[allow(clippy::trivially_copy_pass_by_ref)]
    pub const fn submission_id(&self) -> u32 {
        self.submission_id
    }
}

#[derive(Deserialize, Serialize)]
#[derive(Clone)]
#[derive(Debug)]
#[derive(Default)]
#[derive(PartialEq)]
pub struct RunResult {
    #[serde(default)]
    pub elapsed_time: u32,
    #[serde(default)]
    pub finished:     bool,

    // #[serde(default)]
    // pub expected_elapsed_time: u32,
    // #[serde(default)]
    // pub expected_lang: String,
    // #[serde(default)]
    // pub expected_memory: u128,
    // #[serde(default)]
    // pub expected_run_success: bool,
    // #[serde(default)]
    // pub expected_status_code: i32,
    // #[serde(default)]
    // pub expected_status_runtime: String,
    // #[serde(default)]
    // pub expected_std_output_list: Vec<String>,
    // #[serde(default)]
    // pub expected_task_finish_time: u128,
    // #[serde(default)]
    // pub expected_task_name: String,
    // #[serde(default)]
    // pub fast_submit: bool,
    #[serde(default)]
    pub task_name: String,

    #[serde(default)]
    pub status_code: i64,
    #[serde(default)]
    pub status_msg:  String,

    #[serde(default)]
    pub question_id:     String,
    #[serde(default)]
    pub std_output:      String,
    #[serde(default)]
    pub expected_output: String,
    #[serde(default)]
    pub last_testcase:   String,

    #[serde(default)]
    pub code_answer:          Vec<String>,
    // #[serde(default)]
    // pub code_output: String, // test:vec,submit:string, delete the field
    #[serde(default)]
    pub compare_result:       String,
    #[serde(default)]
    pub correct_answer:       bool,
    #[serde(default)]
    pub expected_code_answer: Vec<String>,
    #[serde(default)]
    pub expected_code_output: Vec<String>,

    #[serde(default)]
    pub pretty_lang: String,
    #[serde(default)]
    pub lang:        String,

    #[serde(default)]
    pub memory:            u64,
    #[serde(default)]
    pub status_memory:     String,
    #[serde(default)]
    pub memory_percentile: Option<f64>,

    #[serde(default)]
    pub status_runtime:     String,
    #[serde(default)]
    pub runtime_percentile: Option<f64>,
    #[serde(default)]
    pub run_success:        bool,

    #[serde(default)]
    pub state: String,

    #[serde(default)]
    pub std_output_list: Vec<String>,
    #[serde(default)]
    pub submission_id:   String,

    #[serde(default)]
    pub task_finish_time: u64,

    #[serde(default)]
    pub total_correct:   Option<u64>,
    #[serde(default)]
    pub total_testcases: Option<u64>,

    // runtime error
    #[serde(default)]
    pub full_runtime_error: String,
    #[serde(default)]
    pub runtime_error:      String,

    // compile error
    #[serde(default)]
    pub compile_error:      String,
    #[serde(default)]
    pub full_compile_error: String,
}

impl RunResult {
    pub fn success(&self) -> bool {
        &self.state == "SUCCESS"
    }
    pub fn getting(&self) -> bool {
        &self.state == "STARTED"
    }

    pub fn total_correct(&self) -> u64 {
        self.total_correct.unwrap_or_default()
    }

    pub fn total_testcases(&self) -> u64 {
        self.total_testcases.unwrap_or_default()
    }

    pub fn memory_percentile(&self) -> f64 {
        self.memory_percentile
            .unwrap_or_default()
    }

    pub fn runtime_percentile(&self) -> f64 {
        self.runtime_percentile
            .unwrap_or_default()
    }
}

#[derive(Clone)]
#[derive(Debug)]
#[derive(Default)]
pub struct RunResultBuild {
    inner: RunResult,
}

impl RunResultBuild {
    pub fn set_status_msg(mut self, status_msg: String) -> Self {
        self.inner.status_msg = status_msg;
        self
    }
    pub fn build(self) -> RunResult {
        self.inner
    }
}