#!/usr/bin/env python

import cipres
import os
import shutil
import subprocess
import sys

from os import path


def get_usage_message(script_name):
    return "usage: %s topdir confdir propfile target" % (path.basename(script_name))


def check_admin_account(sdk_versions_dir):
    dev_null = open(os.devnull, "wb")

    try:
        args = [path.join(sdk_versions_dir, "cipresAdmin"), "-l"]
        process = subprocess.Popen(args, stdout=dev_null, stderr=sys.stdout)

        returncode = process.wait()

        if returncode != 0:
            print "There are no administrator accounts in the database.\nCreate one by running cipresAdmin. Then create the REST api\ntest and demo accounts by running testAndDemoAccounts."

    finally:
        dev_null.close()


def main(argv):
    try:
        if len(argv) != 5:
            raise cipres.BuildError(get_usage_message(argv[0]))

        top_dir = argv[1]
        conf_dir = argv[2]
        prop_file = argv[3]
        clean_target = False
        prepare_target = False
        prepare_props_target = False
        package_target = False
        deploy_target = False

        if argv[4] == "clean":
            clean_target = True
        elif argv[4] == "prepare":
            prepare_target = True
        elif argv[4] == "prepare-props":
            prepare_props_target = True
        elif argv[4] == "package":
            package_target = True
        elif argv[4] == "deploy":
            deploy_target = True
        else:
            raise cipres.BuildError("unknown argument %s\n%s" % (argv[4], get_usage_message(argv[0])))

        if clean_target:
            return 0

        front_end_dir = path.join(top_dir, "rest")
        front_end_build_dir = path.join(top_dir, "build", "rest")
        conf_dir = path.join(conf_dir, "rest")
        build_props = cipres.Properties(prop_file)

        if prepare_props_target:
            build_props["use.rest.callback"] = "true"
            build_props["portal2.protected.pages"] = "/*"

            build_props.saveToFile(prop_file)

        if prepare_target:
            print "\npreparing the REST service source code..."

            cipresrest_build_src_dir = path.join(front_end_build_dir, "cipresrest", "src")
            cipresrest_conf_src_dir = path.join(conf_dir, "cipresrest", "src")
            datatypes_build_src_dir = path.join(front_end_build_dir, "datatypes", "src")
            datatypes_conf_src_dir = path.join(conf_dir, "datatypes", "src")
            pycipres_build_src_dir = path.join(front_end_build_dir, "pycipres")
            pycipres_conf_src_dir = path.join(conf_dir, "pycipres")
            restclient_build_src_dir = path.join(front_end_build_dir, "restclient", "src")
            restclient_conf_src_dir = path.join(conf_dir, "restclient", "src")
            restusers_build_src_dir = path.join(front_end_build_dir, "restusers", "src")
            restusers_conf_src_dir = path.join(conf_dir, "restusers", "src")

            if not path.exists(front_end_build_dir):
                os.mkdir(front_end_build_dir, 0775)

            if not path.exists(cipresrest_build_src_dir):
                os.makedirs(cipresrest_build_src_dir, 0775)

            cipres.copy_tree(None, path.join(front_end_dir, "cipresrest", "src"), cipresrest_build_src_dir)

            if path.exists(cipresrest_conf_src_dir):
                cipres.copy_tree(None, cipresrest_conf_src_dir, cipresrest_build_src_dir)

            if not path.exists(datatypes_build_src_dir):
                os.makedirs(datatypes_build_src_dir, 0775)

            cipres.copy_tree(None, path.join(front_end_dir, "datatypes", "src"), datatypes_build_src_dir)

            if path.exists(datatypes_conf_src_dir):
                cipres.copy_tree(None, datatypes_conf_src_dir, datatypes_build_src_dir)

            if not path.exists(pycipres_build_src_dir):
                os.mkdir(pycipres_build_src_dir, 0775)

            cipres.copy_tree(None, path.join(front_end_dir, "pycipres"), pycipres_build_src_dir)

            if path.exists(pycipres_conf_src_dir):
                cipres.copy_tree(None, pycipres_conf_src_dir, pycipres_build_src_dir)

            if not path.exists(restclient_build_src_dir):
                os.makedirs(restclient_build_src_dir, 0775)

            cipres.copy_tree(None, path.join(front_end_dir, "restclient", "src"), restclient_build_src_dir)

            if path.exists(restclient_conf_src_dir):
                cipres.copy_tree(None, restclient_conf_src_dir, restclient_build_src_dir)

            if not path.exists(restusers_build_src_dir):
                os.makedirs(restusers_build_src_dir, 0775)

            cipres.copy_tree(None, path.join(front_end_dir, "restusers", "src"), restusers_build_src_dir)

            if path.exists(restusers_conf_src_dir):
                cipres.copy_tree(None, restusers_conf_src_dir, restusers_build_src_dir)

        if package_target:
            print "\nbuilding the REST service...\n"

            python_install = build_props.get("python.install", "develop")

            os.chdir(front_end_dir)

            cipres.exec_command(["mvn", "-Dpython.install=%s" % (python_install), "install"])

        if deploy_target:
            print "\ndeploying the REST service..."

            sdk_versions_dir = build_props.get("build.sdk.versionsDir", os.environ.get("SDK_VERSIONS"))

            if sdk_versions_dir is None or len(sdk_versions_dir) == 0:
                raise cipres.BuildError("property build.sdk.versionsDir is missing or empty")

            dest_script_name = path.join(sdk_versions_dir, "testAndDemoAccounts")
            test_data_dir = path.join(sdk_versions_dir, "testdata")

            shutil.copy2(path.join(front_end_dir, "cipresrest", "testAndDemoAccounts"), dest_script_name)
            os.chmod(dest_script_name, 0775)

            shutil.rmtree(test_data_dir, ignore_errors=True)
            shutil.copytree(path.join(front_end_build_dir, "pycipres", "target", "testdata"), test_data_dir)
            os.chmod(path.join(test_data_dir, "pycipres.conf"), 0600)

            tomcat_dir = build_props.get("build.portal.tomcatDir", os.environ.get("CATALINA_HOME"))

            if tomcat_dir is None or len(tomcat_dir) == 0:
                raise cipres.BuildError("property build.portal.tomcatDir is missing or empty")

            tomcat_webapps_dir = path.join(tomcat_dir, "webapps")

            shutil.rmtree(path.join(tomcat_dir, "work"), ignore_errors=True)
            shutil.rmtree(path.join(tomcat_webapps_dir, "cipresrest"), ignore_errors=True)
            shutil.rmtree(path.join(tomcat_webapps_dir, "restclient"), ignore_errors=True)
            shutil.rmtree(path.join(tomcat_webapps_dir, "restusers"), ignore_errors=True)
            shutil.copy2(path.join(front_end_build_dir, "cipresrest", "target", "cipresrest.war"), tomcat_webapps_dir)
            shutil.copy2(path.join(front_end_build_dir, "restclient", "target", "restclient.war"), tomcat_webapps_dir)
            shutil.copy2(path.join(front_end_build_dir, "restusers", "target", "restusers.war"), tomcat_webapps_dir)

            check_admin_account(sdk_versions_dir)

        return 0

    except (IOError, OSError, cipres.BuildError) as err:
        sys.stderr.write("%s\n" % str(err))

        return 1


if __name__ == "__main__":
    sys.exit(main(sys.argv))