aoc2017-day18-2

getop = fn (state, x) ->                                                                                                                                                                                            
  try do                                                                                                                                                                                                            
    String.to_integer(x)                                                                                                                                                                                            
  rescue                                                                                                                                                                                                            
    _ -> Map.get(state, x, 0)                                                                                                                                                                                       
  end                                                                                                                                                                                                               
end                                                                                                                                                                                                                 
setop = fn (state, x, y) -> Map.put(state, x, y) end                                                                                                                                                                
                                                                                                                                                                                                                    
opadd = fn (state, x, y) -> getop.(state, x) + getop.(state, y) end                                                                                                                                                 
opmul = fn (state, x, y) -> getop.(state, x) * getop.(state, y) end                                                                                                                                                 
opmod = fn (state, x, y) -> rem(getop.(state, x), getop.(state, y)) end                                                                                                                                             
                                                                                                                                                                                                                    
execute = fn (state, pc, inst) ->                                                                                                                                                                                   
#  inst |> IO.inspect                                                                                                                                                                                               
  { op, x, y } = inst                                                                                                                                                                                               
  new =                                                                                                                                                                                                             
    case op do                                                                                                                                                                                                      
      "add" -> setop.(state, x, opadd.(state, x, y))                                                                                                                                                                
      "mul" -> setop.(state, x, opmul.(state, x, y))                                                                                                                                                                
      "mod" -> setop.(state, x, opmod.(state, x, y))                                                                                                                                                                
      "set" -> setop.(state, x, getop.(state, y))                                                                                                                                                                   
    end                                                                                                                                                                                                             
  { new, pc + 1 }                                                                                                                                                                                                   
end                                                                                                                                                                                                                 
                                                                                                                                                                                                                    
execute_and_next = fn {state, pc, prog} ->                                                                                                                                                                          
  inst = Enum.at(prog, pc)                                                                                                                                                                                          
  { state, pc } =                                                                                                                                                                                                   
    case inst do                                                                                                                                                                                                    
      nil -> { state, nil }                                                                                                                                                                                         
      _ -> execute.(state, pc, Enum.at(prog, pc))                                                                                                                                                                   
    end                                                                                                                                                                                                             
  { state, pc, prog }                                                                                                                                                                                               
end                                                                                                                                                                                                                 
                                                                                                                                                                                                                    
runner = fn (state, prog, stop) ->                                                                                                                                                                                  
  gen = Stream.resource(                                                                                                                                                                                            
  fn -> { state, 0, prog } end,                                                                                                                                                                                     
  fn x ->                                                                                                                                                                                                           
    case stop.(x) do                                                                                                                                                                                                
      :halt -> {:halt, x }                                                                                                                                                                                          
      x ->                                                                                                                                                                                                          
        n = execute_and_next.(x)                                                                                                                                                                                    
        { [n], n }                                                                                                                                                                                                  
    end                                                                                                                                                                                                             
  end,                                                                                                                                                                                                              
  fn x -> x end)                                                                                                                                                                                                    
  |> Stream.take(-1)                                                                                                                                                                                                
  |> Enum.to_list                                                                                                                                                                                                   
                                                                                                                                                                                                                    
  elem(Enum.at(gen, 0), 0)                                                                                                                                                                                          
end                                                                                                                                                                                                                 
                                                                                                                                                                                                                    
stop = fn { state, pc, prog } ->                                                                                                                                                                                    
  case Enum.at(prog, pc) do                                                                                                                                                                                         
    nil -> :halt                                                                                                                                                                                                    
    _ -> { state, pc, prog }                                                                                                                                                                                        
  end                                                                                                                                                                                                               
end                                                                                                                                                                                                                 
                                                                                                                                                                                                                    
thread = fn ->        
  receive do x ->                                                                                                                                                                                                   
      send x.parent,                                                                                                                                                                                                
        %{ child: x.state["p"],                                                                                                                                                                                     
           state: runner.(x.state, x.prog, stop) }                                                                                                                                                                  
  end                                                                                                                                                                                                               
end                                                                                                                                                                                                                 
                                                                                                                                                                                                                    
#prog = [ {"set", "a", "1" }, { "add", "a", "2" }, { "set", "b", "a"} ]                                                                                                                                             
prog = :stdio                                                                                                                                                                                                       
|> IO.read(:all)                                                                                                                                                                                                    
|> String.split("\n")                                                                                                                                                                                               
|> Enum.map(&(String.trim(&1)))                                                                                                                                                                                     
|> Enum.filter(&(&1 != ""))                                                                                                                                                                                         
|> Enum.map(&(List.to_tuple(String.split(&1, " "))))                                                                                                                                                                
prog |> IO.inspect                                                                                                                                                                                                  
                                                                                                                                                                                                                    
pid0 = spawn_link thread                                                                                                                                                                                            
pid1 = spawn_link thread                                                                                                                                                                                            
                                                                                                                                                                                                                    
send pid0, %{ parent: self(), state: %{"p" => 0}, prog: prog}                                                                                                                                                       
send pid1, %{ parent: self(), state: %{"p" => 1}, prog: prog}                                                                                                                                                       
                                                                                                                                                                                                                    
receive do x -> x end                                                                                                                                                                                               
|> IO.inspect                                                                                                                                                                                                       
receive do x -> x end                                                                                                                                                                                               
|> IO.inspect