#!/usr/bin/python3
'''
  # nsreconfig.py, version 3.0
  # (c) 2002-2008,2014,2022 Jan ONDREJ (SAL) <ondrejj(at)salstar.sk>
  # Licensed under GNU GPLv2+.

  # You can use standard netsaint commands as:
  #   command[...]=...
  # Also you can use varaibles:
  #   var="$1;..."
  # Add to variable:
  #   var+string
  #   - this is replaced by:
  #     var="$var,string" or var="string"
  # Any variable can be user as command:
  #   var param1;param2;...
  # And repetition operator:
  #   @param1;param2;... cmd1,cmd2,...
  #   - this is replaced by:
  #     cmd1 param1;param2;...
  #     cmd2 param1;param2;...
  #     ...
  #   - paramters can be separated by " ", ",", ";"
  # Include file:
  #   <filename
'''

from __future__ import print_function

import sys, re

class code():
  def __init__(self):
      self.reset()
  def reset(self):
      self.data = []
      self.s_quot = 0
      self.s_bracket_open = 0
      self.s_bracket_close = 0
  def append(self, data):
      self.data.append(data)
      self.s_quot += data.count('"')
      self.s_bracket_open += data.count("{")
      self.s_bracket_close += data.count("}")
  def is_complete(self):
      return self.s_quot%2==0 and self.s_bracket_open==self.s_bracket_close
  def get(self):
      ret = "\n".join(self.data)
      self.reset()
      return ret

class reconfigurator():
  c = []
  size_x = 60
  size_y = 80
  start_x = 25
  start_y = 25
  pos_x = start_x
  pos_y = start_y

  cmdt = dict(echo="$1", _="\n")
  reg_cache = {}

  def __init__(self, f):
      self.fhost = open(sys.argv[2], "w")
      self.include_file(f)
      self.fhost.close()

  def include_file(self, f):
      s = code()
      cnf = open(f, "r")
      while True:
          line = cnf.readline()
          if not line: break
          #s.append(re.compile("#.*$").sub("", line.rstrip()))
          s.append(line.split("#", 1)[0].rstrip())
          if s.is_complete():
              #break
              self.fhost.write(self.chk(s.get()))
      cnf.close()

  def ereg(self, exp, s, cmds=[]):
      if exp not in self.reg_cache:
        self.reg_cache[exp] = re.compile(exp)
      r = self.reg_cache[exp].match(s)
      if r:
        self.c = r.groups()
      if cmds and r and (self.c[0] not in cmds):
        return None
      return r

  def chk(self, s):
      if s.startswith("<") or s.startswith(">"):
        # include file
        self.include_file(s[1:])
      elif '=' in s and self.ereg(r'^[ ]*([a-zA-Z0-9_.]+)=\"?([^"]*)\"?$', s):
        # variable assignment
        self.cmdt[self.c[0]] = self.c[1]

      # image position manipulation
      elif s.startswith('moveto '):
        self.pos_x = self.start_x + float(s.split(' ', 2)[1])*self.size_x
        self.pos_y = self.start_y + float(s.split(' ', 2)[2])*self.size_y
      elif s=='startx':
        self.start_x = self.pos_x
      elif s.startswith('startx '):
        self.start_x = int(s.split(' ', 1)[1])
      elif s=='nextrow':
        self.pos_y += self.size_y
        self.pos_x = self.start_x
      elif s.startswith('nextrow '):
        self.pos_y += float(s.split(' ', 1)[1])*self.size_y
        self.pos_x = self.start_x
      elif s=='empty':
        self.pos_x += self.size_x
      elif s.startswith('empty '):
        self.pos_x += float(s.split(' ', 1)[1])*self.size_x
      elif s.startswith('hostextinfo ') and s.count(';')<3:
        ret = self.chk(s+';%d,%d' % (self.pos_x, self.pos_y))
        self.pos_x += self.size_x
        return ret

      # other
      elif self.ereg(r"^[ ]*([a-zA-Z0-9_.]+)\+(.*)$", s):
        if self.c[0] in self.cmdt:
          self.cmdt[self.c[0]] = self.cmdt[self.c[0]]+","+self.c[1]
        else:
          self.cmdt[self.c[0]] = self.c[1]
      elif s.strip().split(" ", 1)[0] in self.cmdt and \
             self.ereg(r"^[ \t]*([a-zA-Z0-9_]+)[ \t]*[( ](.*)\)?$", s, self.cmdt):
        mcmd = self.cmdt[self.c[0]]
        margs = self.c[1].split(";")
        for i in range(1, 10):
          if len(margs)>=i:
            mcmd = mcmd.replace("$%d" % i, margs[i-1])
        for key, value in self.cmdt.items():
          if ("$"+key) in mcmd:
            mcmd = re.compile(r"\$%s([^a-zA-Z0-9_]|$)" % key
                              ).sub(value+"\\1", mcmd)
        return mcmd+"\n"
      elif s.lstrip().startswith("@") and \
          self.ereg(r"^@([-a-zA-Z0-9_;.]*) (.*)$", s):
        # split by " ,;" but not within parentheses
        ca = re.split(r"[ ,;]\s*(?![^()]*\))", self.c[1])
        c0 = self.c[0]
        ret = []
        for value in ca:
          with_arg = re.compile(r"^([a-z0-9_-]+)\((.+)\)$").match(value)
          if with_arg:
            ret.append(self.chk("%s %s;%s" \
                       % (with_arg.group(1), c0, with_arg.group(2))))
          else:
            ret.append(self.chk("%s %s" % (value, c0)))
        return ''.join(ret)
      elif self.ereg(r"^[ ]*[a-zA-Z0-9_.]*\[", s):
        #print(s)
        return s+"\n"
      elif self.ereg(r"^define [a-zA-Z0-9_.]+[ \t]*\{", s):
        #print(s)
        return s+"\n"
      elif s!="":
        print("# Illegal command: '%s'" % s)
      return ""

reconfigurator(sys.argv[1])