1use crate::normalize::RANGE_CHAR;
8use crate::{ParseError, Salary, SalaryBounds, SalaryType};
9
10type AmountOutcome = Result<(u64, Option<u64>), ParseError>;
12
13const MONTHLY_KEYWORDS: &[&str] = &[
15 "月収手当込",
16 "月額平均",
17 "月額合計",
18 "月固定給",
19 "月給額",
20 "月給月",
21 "固定給",
22 "月給",
23 "月額",
24 "月収",
25];
26const YEARLY_KEYWORDS: &[&str] = &["年俸制", "年収例", "年収", "年俸", "年棒"];
28const BASE_KEYWORDS: &[&str] = &[
31 "基本給月額平均又は時間額",
32 "初任給",
33 "総支給",
34 "基本給",
35 "正社員",
36 "正職員",
37 "給与",
38 "給料",
39 "基本",
40 "総額",
41 "本給",
42 "常勤",
43];
44const DAILY_KEYWORDS: &[&str] = &["日給"];
46const HOURLY_KEYWORDS: &[&str] = &["時間給", "時給制", "時給"];
48
49const GROUPS: &[(&[&str], Option<SalaryType>)] = &[
51 (MONTHLY_KEYWORDS, Some(SalaryType::Monthly)),
52 (YEARLY_KEYWORDS, Some(SalaryType::Yearly)),
53 (BASE_KEYWORDS, None),
54 (DAILY_KEYWORDS, Some(SalaryType::Daily)),
55 (HOURLY_KEYWORDS, Some(SalaryType::Hourly)),
56];
57
58const NON_SALARY_KEYWORDS: &[&str] = &[
68 "支度金",
69 "祝い金",
70 "祝金",
71 "一時金",
72 "報奨金",
73 "見舞金",
74 "寸志",
75 "交通費",
76 "通勤費",
77 "退職金",
78 "資本金",
79 "年商",
80 "保証金",
81 "賞与",
82 "手当",
83];
84
85const KEYWORD_GAP_CHARS: [char; 3] = ['約', '例', '/'];
87
88const INFER_YEARLY_MIN_YEN: u64 = 1_000_000;
90const INFER_MONTHLY_MIN_YEN: u64 = 60_000;
92const INFER_HOURLY_MIN_YEN: u64 = 820;
94const INFER_HOURLY_MAX_YEN: u64 = 5_000;
96
97pub(crate) fn extract(normalized: &str, bounds: &SalaryBounds) -> Result<Salary, ParseError> {
108 let chars: Vec<char> = normalized.chars().collect();
109 let mut deferred: Option<ParseError> = None;
110
111 if chars.first() == Some(&'月')
114 && chars.get(1).is_some_and(char::is_ascii_digit)
115 && let Some(outcome) = parse_amount_at(&chars, 1)
116 && let Some(parsed) =
117 try_candidate(outcome, Some(SalaryType::Monthly), bounds, &mut deferred)
118 {
119 return Ok(parsed);
120 }
121 for (keywords, salary_type) in GROUPS {
123 for keyword in *keywords {
124 let keyword_chars: Vec<char> = keyword.chars().collect();
125 for pos in keyword_positions(&chars, &keyword_chars) {
126 let Some(outcome) = parse_amount_at(&chars, pos + keyword_chars.len()) else {
127 continue;
128 };
129 if let Some(parsed) = try_candidate(outcome, *salary_type, bounds, &mut deferred) {
130 return Ok(parsed);
131 }
132 }
133 }
134 }
135 if chars.first().is_some_and(char::is_ascii_digit)
139 && !contains_non_salary_keyword(&chars)
140 && let Some(outcome) = parse_amount_at(&chars, 0)
141 && let Some(parsed) = try_candidate(outcome, None, bounds, &mut deferred)
142 {
143 return Ok(parsed);
144 }
145
146 if let Some(error) = deferred {
147 return Err(error);
148 }
149 if has_amount(&chars) {
150 return Err(ParseError::UnknownType {
151 normalized: normalized.to_string(),
152 });
153 }
154 Err(ParseError::NoAmount)
155}
156
157fn try_candidate(
160 outcome: AmountOutcome,
161 salary_type: Option<SalaryType>,
162 bounds: &SalaryBounds,
163 deferred: &mut Option<ParseError>,
164) -> Option<Salary> {
165 let (min_yen, max_yen) = match outcome {
166 Ok(amounts) => amounts,
167 Err(error) => {
168 defer(deferred, error);
169 return None;
170 }
171 };
172 let resolved = salary_type.or_else(|| infer_type(min_yen, max_yen))?;
173 match validate(resolved, min_yen, max_yen, bounds) {
174 Ok(()) => Some(Salary {
175 salary_type: resolved,
176 min_yen,
177 max_yen,
178 }),
179 Err(error) => {
180 defer(deferred, error);
181 None
182 }
183 }
184}
185
186fn defer(slot: &mut Option<ParseError>, error: ParseError) {
188 if slot.is_none() {
189 *slot = Some(error);
190 }
191}
192
193fn parse_amount_at(chars: &[char], start: usize) -> Option<AmountOutcome> {
199 let mut i = start;
200 while matches!(chars.get(i), Some(c) if KEYWORD_GAP_CHARS.contains(c)) {
201 i += 1;
202 }
203 let (min_digits, after_min) = read_digits(chars, i);
204 if min_digits.is_empty() {
205 return None;
206 }
207 i = after_min;
208 if chars.get(i) != Some(&'円') {
209 return None;
210 }
211 i += 1;
212 let min_yen = match parse_amount(&min_digits) {
213 Ok(value) => value,
214 Err(error) => return Some(Err(error)),
215 };
216 if chars.get(i) != Some(&RANGE_CHAR) {
217 return Some(Ok((min_yen, None)));
218 }
219 i += 1;
220 let (max_digits, after_max) = read_digits(chars, i);
221 if max_digits.is_empty() || chars.get(after_max) != Some(&'円') {
222 return Some(Ok((min_yen, None)));
224 }
225 match parse_amount(&max_digits) {
226 Ok(max_yen) => Some(Ok((min_yen, Some(max_yen)))),
227 Err(error) => Some(Err(error)),
228 }
229}
230
231fn read_digits(chars: &[char], start: usize) -> (String, usize) {
233 let mut digits = String::new();
234 let mut i = start;
235 while let Some(c) = chars.get(i) {
236 if !c.is_ascii_digit() {
237 break;
238 }
239 digits.push(*c);
240 i += 1;
241 }
242 (digits, i)
243}
244
245fn parse_amount(digits: &str) -> Result<u64, ParseError> {
247 digits
248 .parse::<u64>()
249 .map_err(|_| ParseError::AmountTooLarge {
250 digits: digits.to_string(),
251 })
252}
253
254fn contains_non_salary_keyword(chars: &[char]) -> bool {
256 NON_SALARY_KEYWORDS.iter().any(|word| {
257 let word_chars: Vec<char> = word.chars().collect();
258 !keyword_positions(chars, &word_chars).is_empty()
259 })
260}
261
262fn keyword_positions(chars: &[char], keyword: &[char]) -> Vec<usize> {
264 if chars.len() < keyword.len() {
265 return Vec::new();
266 }
267 (0..=chars.len() - keyword.len())
268 .filter(|&i| chars[i..i + keyword.len()] == *keyword)
269 .collect()
270}
271
272fn infer_type(min_yen: u64, max_yen: Option<u64>) -> Option<SalaryType> {
281 let max_yen = max_yen.unwrap_or(0);
282 if min_yen >= INFER_YEARLY_MIN_YEN || max_yen >= INFER_YEARLY_MIN_YEN {
283 return Some(SalaryType::Yearly);
284 }
285 if min_yen >= INFER_MONTHLY_MIN_YEN || max_yen >= INFER_MONTHLY_MIN_YEN {
286 return Some(SalaryType::Monthly);
287 }
288 if (INFER_HOURLY_MIN_YEN..=INFER_HOURLY_MAX_YEN).contains(&min_yen)
289 && max_yen <= INFER_HOURLY_MAX_YEN
290 {
291 return Some(SalaryType::Hourly);
292 }
293 None
294}
295
296fn validate(
298 salary_type: SalaryType,
299 min_yen: u64,
300 max_yen: Option<u64>,
301 bounds: &SalaryBounds,
302) -> Result<(), ParseError> {
303 if let Some(max) = max_yen
304 && max < min_yen
305 {
306 return Err(ParseError::InvertedRange { min: min_yen, max });
307 }
308 let range = bounds.range(salary_type);
309 if !range.contains(&min_yen) {
310 return Err(ParseError::OutOfRange {
311 salary_type,
312 amount: min_yen,
313 });
314 }
315 if let Some(max) = max_yen
316 && !range.contains(&max)
317 {
318 return Err(ParseError::OutOfRange {
319 salary_type,
320 amount: max,
321 });
322 }
323 Ok(())
324}
325
326fn has_amount(chars: &[char]) -> bool {
328 chars
329 .windows(2)
330 .any(|pair| pair[0].is_ascii_digit() && pair[1] == '円')
331}