#!/usr/bin/env python3

class Command:
  cmd_string = 'cmd {player} {data}'
  def __init__(self, player: int, data: str):
    self.player = player
    self.data = data

  def to_string(self) -> str:
    return self.cmd_string.format(player = self.player, data = self.data)

class Hash:
  hash_string = '{type} {hash}'
  def __init__(self, type: str, hash: str):
    self.type = type
    self.hash = hash

  def to_string(self) -> str:
    return self.hash_string.format(type = self.type, hash = self.hash)

class Turn:
  turn_string = 'turn {turn} {length}'
  def __init__(self, input_lines: [str]):
    self.cmds = []
    for line in input_lines:
      if line.startswith('turn'):
        unused, turn, length = line.split()
        self.turn = int(turn)
        self.length = int(length)
      elif line.startswith('cmd'):
        unused, player, data = line.split()
        self.cmds.append(Command(player, data))

  def add_hash(self, input_line: str):
    type, hash = input_line.split()
    self.hash = Hash(type, hash)

  def add_turns(self, turns_to_add: int):
    self.turn += turns_to_add

  def write(self, output_file) -> str:
    data = []
    data.append(self.turn_string.format(turn = self.turn, length = self.length))
    for cmd in self.cmds:
      data.append(cmd.to_string())
    data.append('end')
    if hasattr(self, 'hash'):
      data.append(self.hash.to_string())
    output_file.writelines('\n'.join(data) + '\n')

class Commands:
  start_string = 'start {data}'
  def __init__(self, input_folder: str):
    self.turns = []
    with open(input_folder + "/commands.txt") as file:
      key, value = file.readline().split(" ", 1)
      if key == 'start':
        self.start = value
      else:
        print("Expected 'start' as a first line.")
      lines = []
      while True:
        line = file.readline()
        if not line: break
        if line.startswith('end'):
          self.turns.append(Turn(lines))
          del lines[:]
        elif line.startswith('hash'):
          self.turns[-1].add_hash(line)
        else:
          lines.append(line)

  def append(self, commands):
    turns_to_add = len(self.turns)
    for turn in commands.turns:
      turn.add_turns(turns_to_add)
      self.turns.append(turn)

  def write(self, output_folder: str):
    with open(output_folder + "/commands.txt", 'w') as file:
      file.write(self.start_string.format(data = self.start))
      for turn in self.turns:
        turn.write(file)

class MetaData:
  def __init__(self, input_folder: str):
    with open(input_folder + "/metadata.json") as file:
      pass

  def append(self, metadata):
    print("We ought to append the metadata here.")

  def write(self, output_folder):
    with open(output_folder + "/metadata.json", 'w'):
      print("NYI")

class Replay:
  def __init__(self, input_folder: str):
    self.commands = Commands(input_folder)
    self.metadata = MetaData(input_folder)

  def append(self, replay):
    self.commands.append(replay.commands)
    self.metadata.append(replay.metadata)

  def write(self, output_folder: str):
    self.commands.write(output_folder)
#    self.metadata.write(output_folder)

def run (input_folders: [str], output_folder: str):
  base_replay = Replay(input_folders.pop(0))
  for input_folder in input_folders:
    base_replay.append(Replay(input_folder))
  base_replay.write(output_folder)

if __name__ == "__main__":
  import argparse

  parser = argparse.ArgumentParser(description="A simple (dumb) script to merge replays.")
  parser.add_argument('--input', '-i', action='extend', default=[], dest='input_folder', help='Provide the folder of the replay.', nargs='+', required=True, type=str)
  parser.add_argument('--output', '-o', default='.', dest='output_folder', help='Provide the folder to write to.')
  args = parser.parse_args()

  run(input_folders=args.input_folder, output_folder=args.output_folder)