"""
Generator application that generates c++ interfaces code from xml description

usage: Generator.py [-h] --parser-type {sdlrpcv2}
                    source-xml namespace output-dir

SmartSchema interface generator

positional arguments:
  source-xml
  namespace
  output-dir

optional arguments:
  -h, --help            show this help message and exit
  --parser-type {sdlrpcv2}
"""

import os.path
import argparse
import errno
import sys

import generator.parsers.SDLRPCV1
import generator.parsers.SDLRPCV2
import generator.parsers.JSONRPC
import generator.generators.SmartFactorySDLRPC
import generator.generators.SmartFactoryJSONRPC

from generator.parsers.RPCBase import ParseError
from generator.generators.SmartFactoryBase import GenerateError

SUPPORTED_FORMATS = {
    "sdlrpcv1": (generator.parsers.SDLRPCV1.Parser,
                 generator.generators.SmartFactorySDLRPC.CodeGenerator),
    "sdlrpcv2": (generator.parsers.SDLRPCV2.Parser,
                 generator.generators.SmartFactorySDLRPC.CodeGenerator),
    "jsonrpc": (generator.parsers.JSONRPC.Parser,
                generator.generators.SmartFactoryJSONRPC.CodeGenerator)
}


def _create_parser():
    """Create parser for parsing command-line arguments.

    Returns an instance of argparse.ArgumentParser

    """

    parser = argparse.ArgumentParser(
        description="SmartSchema interface generator"
    )
    parser.add_argument("source-xml")
    parser.add_argument("namespace")
    parser.add_argument("output-dir")
    parser.add_argument("--parser-type",
                        choices=SUPPORTED_FORMATS.keys(),
                        required=True)
    return parser


def _handle_fatal_error(error):
    """Handle fatal error during parsing or code generation.

    Keyword arguments:
    error -- base exception to handle.

    """

    print(error.message)
    print
    sys.exit(errno.EINVAL)


def main():
    """Main function of the generator that does actual work."""

    args = vars(_create_parser().parse_args())

    src_xml = args["source-xml"]
    src_xml_name = os.path.splitext(os.path.basename(src_xml))[0]
    namespace = args["namespace"]
    output_dir = args["output-dir"]
    parser_type = args["parser_type"]

    print("""
Generating interface source code with following parameters:
    Source xml      : {0}
    Namespace       : {1}
    Output directory: {2}
    Parser type     : {3}
""".format(src_xml, namespace, output_dir, parser_type))

    # Select required parser and code generator
    parser = SUPPORTED_FORMATS[parser_type][0]()
    code_generator = SUPPORTED_FORMATS[parser_type][1]()

    # Convert incoming xml to internal model
    try:
        interface = parser.parse(args["source-xml"])
    except ParseError as error:
        _handle_fatal_error(error)

    # Generate SmartFactory source code from internal model
    try:
        code_generator.generate(interface,
                                src_xml_name,
                                namespace,
                                output_dir)
    except GenerateError as error:
        _handle_fatal_error(error)

    print("Done.")

if __name__ == '__main__':
    main()