# takes: fei (either xml or text) and smv,
# and produces smv and fault modes files

import sys
import os.path
import logging
import _paths
import _utils


def get_expanded_fei_fname(fei_txt_fname):
    """Given the fei text file name, provides the file name of the
    expanded fei """

    base_in, _ext = os.path.splitext(fei_txt_fname)
    return os.path.basename(base_in) + ".xml"


def get_extended_smv_fname(smv_fname):
    full_base, ext = os.path.splitext(smv_fname)
    base = os.path.basename(full_base)
    prefix = "extended_"
    return prefix + base + ext


def compile_fei(fei_xml_fname, out_xml_fname, lib_path=None):
    from feic import feicm

    feicm.main(fei_xml_fname, out_xml_fname,
               lib_path or feicm.get_default_fault_lib_path())


def translate_fei_to_xml(fei_txt_fname, outdir, path):
    """returns the name of generated xml file. Raises RuntimeError
    is an error occurs while parsing"""
    from feic.translate import fei_translator

    out_fei_xml = os.path.join(outdir, get_expanded_fei_fname(fei_txt_fname))

    fei_translator.convert_fei_text_to_xml_format(
        fei_txt_fname, out_fei_xml, path)
    logging.info("Generated XML fei: " + out_fei_xml)
    return out_fei_xml


def extend_model(smv_fname, fei_fname, outdir,
                 disable_checks=False, disable_cc=False,
                 anonymize=False):
    import subprocess

    if not os.path.exists(_paths.BIN_DIR) or not os.path.isdir(_paths.BIN_DIR):
        raise RuntimeError("Could not find bin directory containing xsap")

    cmd_pat = """set on_failure_script_quits
read_model -i "{smv_in}"
flatten_hierarchy
fe_load_doc -o "{error_fname}" {disable_checks} -p "{dtd_path}" -i "{xml_fei}"
fe_extend_module -m "{fms_fname}" {disable_cc} {anonymize} -o "{smv_out}"
quit
"""
    smv_out = os.path.join(outdir,
                           get_extended_smv_fname(smv_fname))

    fms_fname = os.path.join(outdir,
                             _utils.get_fms_fname(smv_out))

    stdouterr_fname = os.path.join(outdir, "xsap_extend_model.out")
    if os.path.exists(stdouterr_fname):
        os.remove(stdouterr_fname)

    error_fname = os.path.join(outdir, "errors.log")
    if os.path.exists(error_fname):
        os.remove(error_fname)

    # generate command file
    cmd_fname = os.path.join(outdir, "xsap_extend_model.cmd")
    with open(cmd_fname, "w") as _cmd_file:
        _cmd_file.write(cmd_pat.format(
            smv_in=smv_fname,
            error_fname=error_fname,
            disable_checks="-c" if disable_checks else "",
            dtd_path=_paths.SCHEMA_DIR,
            xml_fei=fei_fname,
            fms_fname=fms_fname,
            disable_cc="-c" if disable_cc else "",
            anonymize="-A" if anonymize else "",
            smv_out=smv_out))
    logging.info("Generated xsap commands script: " + cmd_fname)

    logging.info("Invoking xsap to carry out smv extension of " + smv_fname)

    exe_name = _utils.get_exec_fullname()

    args = [exe_name, "-source", cmd_fname]

    with open(stdouterr_fname, "w") as o_file:
        o_file.write("\n" + "-" * 70)
        o_file.write("\nInvoking:\n" + " ".join(args))
        o_file.write("\n" + "-" * 70)
        o_file.write("\nContent of %s is:\n" % cmd_fname)
        o_file.write(open(cmd_fname).read())
        res = subprocess.call(args, stdout=o_file, stderr=subprocess.STDOUT)
        o_file.write("\n" + "-" * 70)
        o_file.write("\nxsap returned %d\n" % res)
        o_file.write("-" * 70 + '\n')

    if res != 0:
        logging.error("A fatal error occurred")
        if os.path.exists(error_fname):
            logging.error("This is content of %s:" % error_fname)
            with open(error_fname) as _err:
                for line in _err:
                    if line.strip():
                        print ("   " + line.strip())

        if os.path.exists(stdouterr_fname):
            logging.error("(See also content of file %s)" % stdouterr_fname)

        sys.exit(1)

    else:
        logging.info("Successfully created:")
        logging.info(" - Extend smv file: '%s'" % smv_out)
        logging.info(" - Fault modes xml file: '%s'" % fms_fname)

    return smv_out, fms_fname


def handle_options():
    """returns (options, input_file):
    values (as a map) and the name of the input file"""

    import argparse
    parser = argparse.ArgumentParser(description="Produces an extend smv file"
                                     " out of given nominal smv file and fei")

    parser.add_argument("smv_file",
                        metavar="SMV-FILE",
                        help="The input nominal smv file name")

    parser.add_argument("fei_file",
                        metavar="FEI-FILE",
                        #dest="fei_file",
                        help="The input fei file name")

    parser.add_argument('--xml-fei', '-x',
                        action='store_true',
                        default=False,
                        help='Process XML-format for input fei file')

    parser.add_argument('--verbose', '-v',
                        action='store_true',
                        default=False,
                        help='Sets verbosity to high level')

    parser.add_argument('--disable-checks', '-c',
                        action='store_true',
                        default=False,
                        help='Disable semantics checks when '
                        'extending model (for debugging)')

    parser.add_argument(
        "-p", "--path",
        default=os.path.join(_paths.DATA_DIR, "fm_library"),
        metavar="PATH",
        help="Path to the extension library (default:%(default)s)")

    parser.add_argument(
        "-d", "--outdir",
        default="out",
        metavar="PATH",
        help="Output directory, where all generated file should be "
        "put into (default:%(default)s)")

    parser.add_argument('--disable-cc', '-C',
                        action='store_true',
                        default=False,
                        help='Disable generation of common cause encoding '
                        'when extending model (for debugging)')

    parser.add_argument('--anonymize', '-A',
                        action='store_true',
                        default=False,
                        help='Anonymize the generated extended model')

    args = parser.parse_args()

    for fn in (args.smv_file, args.fei_file):
        if not os.path.isfile(fn):
            parser.error("File not found: " + fn)

    if os.path.exists(args.outdir) and not os.path.isdir(args.outdir):
        parser.error("Not a directory: " + args.outdir)

    return args


if "__main__" == __name__:
    _paths.setup_path()
    args = handle_options()

    if not os.path.exists(args.outdir):
        os.makedirs(args.outdir)

    if args.verbose:
        logging.getLogger().setLevel(logging.INFO)

    # convert text format if user specified text format as input
    try:
        fei_in = (translate_fei_to_xml(args.fei_file, args.outdir, args.path)
                  if not args.xml_fei
                  else args.fei_file)

    except RuntimeError as e:
        logging.error(e)
        sys.exit(1)

    base_in, _ext = os.path.splitext(args.fei_file)

    out_fei_fname = os.path.join(
        args.outdir,
        "expanded_" + os.path.basename(base_in) + ".xml")

    if os.path.isfile(out_fei_fname):
        logging.info("Removing previously generated expanded XML fei: " +
                     out_fei_fname)
        os.remove(out_fei_fname)

    logging.info("Generating expanded XML fei: " + out_fei_fname)
    compile_fei(fei_in, out_fei_fname, args.path)

    if not os.path.isfile(out_fei_fname):
        logging.error("An error occurred while generating expanded XML fei: " +
                      out_fei_fname)
    else:
        logging.info("Generated expanded XML fei: " + out_fei_fname)

        out_smv_fname, out_fms = extend_model(
            args.smv_file, out_fei_fname,
            args.outdir,
            disable_checks=args.disable_checks,
            disable_cc=args.disable_cc,
            anonymize=args.anonymize,
        )