library(stringr)  # For all the `str_*()` functions
library(stringi)  # For `stri_replace_all_fixed()`

test_input <- c(
  "2 * 3 + (4 * 5)",
  "5 + (8 * 3 + 9 + 3 * 4 * 3)",
  "5 * 9 * (7 * 3 * 3 + 9 * 3 + (8 + 6 * 4))",
  "((2 + 4 * 9) * (6 + 9 * 8 + 6) + 6) + 2 + 4 * 2"
)
real_input <- readLines('input.txt')


# Given a string with at least some part contained in parentheses 
# `parens_w_contents`, return the string inside the parentheses
parens_contents <- function(parens_w_contents) {
  str_extract(parens_w_contents, '(?<=\\().+(?=\\))')
}


# Given a string `exp_part`, return a list of the string components split
# on space sequences
tokenize <- function(exp_part) {
  str_split(exp_part, '\\s+')
}


# Given a character vector of regex patterns `patterns`, a character vector
# of replacement strings `replacements`, and a string expression `exp`, replace
# each instance of a pattern with the corresponding replacement string in `exp`
sub_value <- function(patterns, replacements, exp) {
  stri_replace_all_fixed(exp, patterns, replacements, vectorize_all = F)
}


# Given a list of character strings `tokens` consisting of either numbers, the
# '+' symbol, or the '*' symbol (notably, no parentheses!) evaluate the tokens
# as a mathematical expression from left to right, as described by the puzzle
# instructions
eval_tokens <- function(tokens) {
  operator <- `+`
  total <- 0
  for (token in tokens) {
    if (str_detect(token, '\\d+')) { 
      next_number <- as.numeric(token)
      total <- operator(total, next_number) 
    } else {
      operator <- match.fun(token)
    }
  }
  total
}


# Given a string containing one or more expressions wrapped in parentheses 
# `exp_w_parens`, evaluate all expressions contained in the innermost set
# of parentheses. 
# Example: `simplify('2 * (3 + (4 * 5) + 6)') => '2 * (3 + 20 + 6)`
# Example: `simplify('(1 + (2 * 3) + (4 + 5)) => '(1 + 6 + 9)`
simplify <- function(exp_w_parens) {
  # Extract all innermost parentheses expressions, with parentheses included
  inner_parens <- str_extract_all(exp_w_parens, '\\([\\d\\s\\+\\*]+\\)')
  
  contents <- lapply(inner_parens, parens_contents)  # Unwrap parentheses
  token_lists <- lapply(contents, tokenize)          # Tokenize the contents
  
  # Evaluate each tokenized `contents` expression
  replacements <- lapply(token_lists, function(x) { lapply(x, eval_tokens) })
  
  # Replace each `inner_parens` string in the original `exp_w_parens` with the
  # evaluated value
  mapply(sub_value, inner_parens, replacements, MoreArgs = list(exp = exp_w_parens))
}


# Given a list of expressions `exps`, repeatedly simplify and evaluate the 
# innermost parenthetical expressions until the expression has been reduced
# to a single value, as shown in the example. As follows:
# '2 * 3 + (4 * 5)' => '2 * 3 + 20' => '6 + 20' => 26
eval_exps <- function(exps) {
  # If the expression contains any parenthetical components, evaluate them
  # starting with the innermost parenthetical components and working outwards
  needs_simplifying <- str_detect(exps, '[\\(\\)]')
  while (any(needs_simplifying)) {
    exps[needs_simplifying] <- lapply(exps[needs_simplifying], simplify)
    needs_simplifying <- str_detect(exps, '[\\(\\)]')
  }
  
  # Once `exps` has been converted entirely to simple tokens, evaluate
  # the entire remaining expressions to a numeric vector
  vapply(tokenize(exps), eval_tokens, numeric(1))
}

results <- eval_exps(real_input)  # Evaluate all the things!
answer1 <- sum(results)           # Sum the results

source('exercise_1.R')

test_input <- c(
  "1 + (2 * 3) + (4 * (5 + 6))",
  "2 * 3 + (4 * 5)",
  "5 + (8 * 3 + 9 + 3 * 4 * 3)",
  "5 * 9 * (7 * 3 * 3 + 9 * 3 + (8 + 6 * 4))",
  "((2 + 4 * 9) * (6 + 9 * 8 + 6) + 6) + 2 + 4 * 2"
)


# Given a list of character strings `tokens` consisting of either numbers, the
# '+' symbol, or the '*' symbol (notably, no parentheses!) evaluate the tokens
# as a mathematical expression as described in the puzzle input
# Example: '2 * 3 + (4 * 5)' => '2 * 3 + 20' => '2 * 23' => '46'
eval_tokens <- function(tokens) {
  total <- 0                 # Running total
  summed_nums <- numeric(0)  # List of summed numbers
  
  # For each token in the list...
  for (token in tokens) {
    
    if (str_detect(token, '\\d+')) { 
      # If the token is a number, then add it to the running total
      next_number <- as.numeric(token)
      total <- total + next_number
    } else if (token == '*') {
      # Otherwise, if the token is a '*' operator, append the running total to 
      # the vector `summed_nums`, then restart the total
      summed_nums <- c(summed_nums, total)
      total <- 0
    }
    
    # Just ignore the '+' operators...
  }
  
  # Finally, multiply all the `summed_nums` (and `total`) together
  prod(summed_nums, total)  
}

results <- eval_exps(real_input)  # Evaluate again!
answer2 <- sum(results)           # Sum the results