use common::*;

#[derive(PartialEq, Debug)]
pub struct CookedString<'a> {
  pub raw: &'a str,
  pub cooked: String,
}

impl<'a> CookedString<'a> {
  pub fn new(token: &Token<'a>) -> CompilationResult<'a, CookedString<'a>> {
    let raw = &token.lexeme[1..token.lexeme.len() - 1];

    if let TokenKind::RawString = token.kind {
      Ok(CookedString {
        cooked: raw.to_string(),
        raw,
      })
    } else if let TokenKind::StringToken = token.kind {
      let mut cooked = String::new();
      let mut escape = false;
      for c in raw.chars() {
        if escape {
          match c {
            'n' => cooked.push('\n'),
            'r' => cooked.push('\r'),
            't' => cooked.push('\t'),
            '\\' => cooked.push('\\'),
            '"' => cooked.push('"'),
            other => {
              return Err(
                token.error(CompilationErrorKind::InvalidEscapeSequence { character: other }),
              )
            }
          }
          escape = false;
          continue;
        }
        if c == '\\' {
          escape = true;
          continue;
        }
        cooked.push(c);
      }
      Ok(CookedString { raw, cooked })
    } else {
      Err(token.error(CompilationErrorKind::Internal {
        message: "cook_string() called on non-string token".to_string(),
      }))
    }
  }
}