#! /usr/bin/python

import socket
import subprocess
import errno
import sys
import os
import json
import traceback
import shlex

class ArgParser:
  def __init__(self):
    self.i = 0
    self.args = []

  def parse_type(self, make_type):
    opt = self.args[self.i]
    self.i += 1
    if self.i >= len(self.args):
      return ("Not enough params to " + opt, None)
    val = None
    try:
      val = self.args[self.i] if make_type is None else make_type(self.args[self.i])
    except Exception, e:
      pass
    if val is None:
      return ("Bad argument to " + opt + ": " + self.args[self.i], None)
    return (None, val)

  def possible(self, opts, make_type):
    return lambda v: make_type(v) if v in opts else None

  def condition(self, make_type, condition):
    return lambda v: make_type(v) if condition(make_type(v)) else None

  def parse_args(self, args):
    self.args = args
    self.i = 0
    ret = {"input":[]}
    allow_opts = True

    while self.i < len(self.args):
      arg = self.args[self.i].strip()
      if arg == "--":
        allow_opts = False
        self.i += 1
        continue

      if arg == "--port" or arg == "-p":
        (msg, p) = self.parse_type(int)
        if msg is not None:
          return (msg, None)
        ret["port"] = p
      elif arg == "--type" or arg == "-t":
        (msg, t) = self.parse_type(self.possible(["1", "3"], int))
        if msg is not None:
          return (msg, None)
        ret["type"] = t
      elif arg == "--scale" or arg == "-s":
        (msg, s) = self.parse_type(self.condition(int, lambda s: s > 0.00001))
        if msg is not None:
          return (msg, None)
        ret["scale"] = s
      else:
        ret["input"].append(arg)
      self.i += 1
    return (None, ret)
      
def usage():
  print "usage 1: ./exporter.py [--port/-p wrapper_communication_port] [--type/-t (1,3)] [--scale/-s skeletal_scale] input_files..."
  print "  Exports the given file(s) with the given settings"
  print
  print "usage 2: ./exporter.py [--port/-p wrapper_communication_port] -"
  print "  Reads commands (everything after --port in usage 1) as lines from stdin"
  print
  print "usage 3: ./export.py  --help|-h"
  print "  Shows this help message"

if "-h" in sys.argv or "--help" in sys.argv:
  usage()
  sys.exit(0)

(err, args) = ArgParser().parse_args(sys.argv[1:])
if err is not None:
  print err
  usage()
  sys.exit(2)

if "-" in args["input"]:
  if len(args["input"]) > 1 or "type" in args or "scale" in args:
    print "If reading from stdin ('-') is specified, no other input may be given"
    usage()
    sys.exit(2)

if not len(args["input"]):
  usage()
  sys.exit(0)

port = 7890

s = socket.socket()
s.bind(("localhost", port))

exporter_args = [os.getcwd() + "/GraphicExport.exe"]
# exporter_args = [os.getcwd() + "/GraphicExport.app/GraphicExport.exe", str(port)]
g = subprocess.Popen(exporter_args, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)

s.settimeout(0.5)
s.listen(0)

conn = None
while conn is None and g.returncode is None:
  try:
    (conn, _) = s.accept()
  except socket.timeout, e:
      pass
  except e:
    print e
    s.close()
    g.wait()
    sys.exit(1)
  g.poll()

if conn:
  conn.setblocking(False)

  conn.send("EXPORT|" + "|".join(sys.argv[1:]) + "\0")

while g.returncode is None:
  try:
    d = conn.recv(4096)
    if len(d):
      sys.stdout.write(d)
      sys.stdout.flush()
  except socket.error, e:
    if e.args[0] == errno.EWOULDBLOCK or e.args[0] == errno.EAGAIN:
      pass
    else:
      print e
      conn.close()
      s.close()
      g.wait()
      sys.exit(1)
  g.poll()

if (conn):
  conn.close()
s.close()