#!/bin/sh
# Boot up Python from Bourne shell.
"exec" "python" "-OO" "$0" "$@"

# Following are Python script. (e.g. boot up `#!/usr/bin/env python')

PROGNAME = 'roap'
__version__ = '0.1.2'

import os, sys, getopt, string, re, copy
from roaplib import generate

# Import roap modules.
__doc__ ="roap base operations."

class Params:
    "Parse paramaters when start up this module."

    def __init__ (self):

        self.helpmsg = """Usage: %s [OPTION]... roap-script-file [input-text-file]

  -V --version
                 output version information and exit

Report bugs to urago@users.sourceforge.net (enable Japanese)""" % (PROGNAME)

        argv = sys.argv[1:]
        if len (argv) == 0:
            self.usage ()

        opts, args = self.__getparam (argv)
        self.args = copy.copy (args)

        # Reparse `sys.argv'.
        if len (opts) == 0 or len (args) > 1:
            self.args = [args[0]]
            argv = args [1:]            
            opts, args = self.__getparam (argv)
            if len (args) > 0:
                map (self.args.append, args)

        # Search args version option.
        # When find it, put info and end this program.
        for item in opts:
            if item[0] == '--version' or item[0] == '-V':
                self.verinfo ()        

        # Parse option paramater.
        try:
            optdict = self.__parse_opts (opts)
        except Exception, e:
            sys.stderr.write ("%s\n" % (e))
            self.usage (e)

        if self.__chkargs () == None:
            self.usage ()

    def __getparam (self, argv):
        "get parameters in getopt module."

        shortopts = "V"
        longopts = ["version"]

        try:
            opts, args = getopt.getopt (argv, shortopts, longopts)
        except Exception, e:
            self.usage (e)
            sys.exit (1)

        if len (args) > 1:
            pass

        return opts, args

    def __chkargs (self):
        "Checking args"

        # Check length of args.
        if len (self.args) == 2:
            text = self.args[1]
            script = self.args[0]
        elif len (self.args) == 1:
            text = None
            script = self.args[0]            
        else:
            return None

        # Assigning text stream.
        try:
            self.script_stream = open (script)
            if text == None:
                self.text_stream = sys.stdin
            else:
                self.text_stream = open (text)
        except Exception, e:
            sys.stderr.write ("%s: %s\n" % (PROGNAME, e))
            sys.exit (2)

        return 1
        
    def getscriptstream (self):
        "Assign script stream."

        return self.script_stream

    def gettextstream (self):
        """
        Exam stream type.

        When the '-' into args set to input stream is stdin.
        """
        return self.text_stream

    def usage (self, emsg = None):
        if emsg == None:
            sys.stderr.write ("%s\n" % (self.helpmsg))
        else:
            sys.stderr.write ("%s: %s\n%s\n" % (PROGNAME, emsg, self.helpmsg))

        sys.exit (1)

    def verinfo (self):
        print "%s version %s" % (PROGNAME, __version__)
        sys.exit (0)
                    
    def __parse_opts (self, opts):
        "parse option args."

        KEY = 0
        VAL = 1

        optlist = {
            'VERSION': '-V',
            'LVERSION': '--version'
            }

        # Scan all option args.
        optdict = {}
        for opt in opts:

            # Put package info.
            if opt[KEY] == optlist['VERSION'] \
               or opt[KEY] == optlist['LVERSION']:
                if not optdict.has_key ('version'):
                    optdict['version'] = opt[VAL]
                else:
                    raise ValueError, \
                          "Invaild option: Specify exist option."

        return optdict

    def getpkgname (self):
        "Tell name of use package."
        return self.pkgname

if __name__ == '__main__':
    # Get paramaters then get stream, packagename, generater.
    params = Params ()
    text_st = params.gettextstream ()
    script_st = params.getscriptstream ()
    generator = generate.RoapGen (text_st, script_st)
    contents = generator.process ()

    # Output and exit this process.
    sys.stdout.write (contents)
