#!/usr/bin/python
# -*- coding: utf-8 -*-


import datetime
import getopt
import os
import shutil
import subprocess
import sys
import time
import ConfigParser
import fnmatch


loc = os.path.dirname(sys.argv[0])
loc = os.path.abspath(loc)
exec(compile(open("helpers.py").read(), "helpers.py", "exec"))


class build(object):
    def __init__(self):
        self.project_name = "ctc"
        self.base_dir = os.getcwd()
        self.cmake_build_flags = None
        self.output_dir = "/shd/CTC/TOOLS/TDS-rpmbuild/"
        self.version_maj = 1
        self.version_min = 1
        self.version_rev = 0
        self.cmake_version_prefix = "TDS"
        self.source_dir_rel = "TDS-Source"
        self.svn_fullpath = None

        self.buildtype = os.getenv("CMAKE_BUILD_TYPE")
        if self.buildtype == None or self.buildtype == "":
            self.buildtype = "RelWithDebInfo"

        self.cmake_generator = "Unix Makefiles"

    def init(self):
        self.extfw_dir = "%s/EXTFW-inst/opt/EXTFW" % self.base_dir
        if not os.path.exists(self.extfw_dir):
            self.extfw_dir = "/opt/EXTFW"
        os.environ["EXTFW"] = self.extfw_dir
        os.environ["CMAKE_PREFIX_PATH"] = self.extfw_dir

    def printOptions(self):
        print("Config options")
        print("**************")
        print(" Using base dir:                     %s" % self.base_dir)
        print(" Using extfw dir:                    %s" % self.extfw_dir)
        print(" Using buildtype:                    %s" % self.buildtype)
        print(" Project name:                       %s" % self.project_name)
        print(" SVN Path:                           %s" % self.svn_fullpath)
        print(
            " Version:                            %s.%s-%s"
            % (self.version_maj, self.version_min, self.version_rev)
        )
        print(" Jenkins build number:               %s" % os.getenv("BUILD_NUMBER"))
        print(" Date:                               %s" % self.version_date)
        print("")
        time.sleep(2)

    def svn_export(
        self, svn_path, dest_dir, svn_revision="HEAD", svn_user=None, svn_passwd=None
    ):

        removeDirectory(dest_dir)

        info("--------------------------------")
        info("Exporting %s to %s" % (svn_path, dest_dir))
        info("--------------------------------")

        command = "svn export -r %s %s %s" % (svn_revision, svn_path, dest_dir)
        if svn_user:
            command += "--username %s " % svn_user
        if svn_passwd:
            command += "--password %s " % svn_passwd
        os.system(command) and die("while svn export. cmd: %s" % command)

    def version_str(self):
        return "%s.%s" % (self.version_maj, self.version_min)

    def xzfilename(self):
        return (
            self.project_name
            + "_"
            + self.repository
            + "_"
            + getOS_Name()
            + "-"
            + self.version_str()
            + ".tar.xz"
        )

    def specname(self, specdir):
        specname = "ctc_%s_%s.spec" % (self.repository, self.project_name)
        debug("specname: %s" % os.path.join(specdir, specname))
        if os.path.exists(os.path.join(specdir, specname)):
            return specname
        specname = "ctc_%s.spec" % (self.repository)
        debug("specname: %s" % os.path.join(specdir, specname))
        if os.path.exists(os.path.join(specdir, specname)):
            return specname
        specname = "lts15.2.spec"
        debug("specname: %s" % os.path.join(specdir, specname))
        if os.path.exists(os.path.join(specdir, specname)):
            return specname
        specname = "ctc.spec"
        debug("specname: %s" % os.path.join(specdir, specname))
        if os.path.exists(os.path.join(specdir, specname)):
            return specname
        specname = "%s.spec" % self.project_name
        debug("specname: %s" % os.path.join(specdir, specname))
        if os.path.exists(os.path.join(specdir, specname)):
            return specname
        die("Unable to find a valid spec file in %s" % specdir)

    def copy_spec(self, svn_fullpath, dest_dir, spec_fullpath):

        f = open(spec_fullpath, "r")
        content = f.read()
        f.close()

        jenkins_build_tag = os.getenv("BUILD_TAG")
        if jenkins_build_tag == None or len(jenkins_build_tag) == 0:
            jenkins_build_tag = "Not build with jenkins job"

        cmake_flags = ""
        cmake_flags += '-D%s_VERSION_MAJOR:STRING="%s" ' % (
            self.cmake_version_prefix,
            self.version_maj,
        )
        cmake_flags += '-D%s_VERSION_MINOR:STRING="%s" ' % (
            self.cmake_version_prefix,
            self.version_min,
        )
        cmake_flags += '-D%s_VERSION_REV:STRING="%s" ' % (
            self.cmake_version_prefix,
            self.version_rev,
        )
        cmake_flags += '-D%s_VERSION_PATCH:STRING="%s" ' % (
            self.cmake_version_prefix,
            self.version_rev,
        )
        cmake_flags += '-D%s_VERSION_DATE:STRING="%s" ' % (
            self.cmake_version_prefix,
            self.version_date,
        )
        jenkins_build_number = os.getenv("BUILD_NUMBER")
        if jenkins_build_number != None:
            cmake_flags += '-DJENKINS_BUILD_NUMBER:STRING="%s" ' % (
                jenkins_build_number
            )

        if self.cmake_build_flags:
            cmake_flags += " %s " % self.cmake_build_flags

        cmake_flags += '-DCMAKE_BUILD_TYPE="%s" ' % self.buildtype

        filename = "project.%s.cfg" % self.project_name
        cmake_flags += "-DTDS_PROJECT_CONFIG_FILE=%s " % filename

        content = content.replace("@PROJECT@", self.project_name)
        content = content.replace("@OS_SYSTEM@", getOS_Name())
        content = content.replace("@PACKAGER@", getpass.getuser())
        content = content.replace("@VERSION@", self.version_str())
        content = content.replace("@RELEASE@", self.version_rev)
        content = content.replace("@SOURCE_DIR_REL@", self.source_dir_rel)
        content = content.replace("@SOURCES@", self.xzfilename())
        content = content.replace("@APPLICATION@", self.repository)
        content = content.replace("@CMAKE_FLAGS@ ", cmake_flags)
        content = content.replace("@JENKINS_BUILD_TAG@", jenkins_build_tag)
        if not os.path.exists(dest_dir):
            os.makedirs(dest_dir)
        f = open(os.path.join(dest_dir, os.path.split(spec_fullpath)[1]), "w")
        f.write(content)
        f.close()

    def clean_lts_cc_conf(self, folder):
        config_files = []
        for root, dirs, files in os.walk(folder):
            for name in files:
                if fnmatch.fnmatch(name, "lts-cc*conf"):
                    config_files.append(os.path.join(root, name))

        for config_file in config_files:
            config = ConfigParser.RawConfigParser()
            config.optionxform = str
            config.read(config_file)

            for section in config.sections():
                if len(config.items(section)) == 0:
                    config.remove_section(section)

            with open(config_file, "w") as file:
                config.write(file)

    def pack_sources(self, src_dir, dest_dir):
        xzfilename = self.xzfilename()
        xzfilename = os.path.join(dest_dir, xzfilename)

        info("--------------------------------")
        info("Packing sources in %s to %s" % (src_dir, xzfilename))
        info("--------------------------------")

        removeDirectory(xzfilename)
        if os.path.exists(xzfilename):
            os.remove(xzfilename)
        if not os.path.exists(dest_dir):
            os.makedirs(dest_dir)

        os.chdir(os.path.split(src_dir)[0])
        cmd = "tar cJf %s %s" % (xzfilename, os.path.split(src_dir)[1])
        system(cmd, sys.stdout) and die("while packing. cmd: %s" % command)


def usage():
    print >> sys.stdout, "Usage: %s [-b <base_dir> ] -f <filelist> -o <output_dir> -r <repository> -v <version> -s <svn_path>" % sys.argv[
        0
    ]


def main():
    b = build()

    try:
        opts, args = getopt.getopt(
            sys.argv[1:],
            "b:c:f:o:p:r:v:s:",
            [
                "base_dir=",
                "cmake_build_flags=",
                "cmake_version_prefix=",
                "filelist=",
                "output_dir=",
                "project_name=",
                "repository",
                "version=",
                "svn_path=",
            ],
        )
    except getopt.GetoptError as err:
        print >> sys.stderr, err
        usage()
        sys.exit(2)

    rpm_filelist = None
    svn_path = "trunk"
    b.repository = "TDS"
    for o, a in opts:
        if o == "--cmake_build_flags":
            b.cmake_build_flags = a
            print("build flags: ", b.cmake_build_flags)
        if o in ("-b", "--base_dir"):
            b.base_dir = a
        if o in ("-f", "--filelist"):
            rpm_filelist = a
        if o in ("-o", "--output_dir"):
            b.output_dir = a
        if o in ("-c", "--cmake_version_prefix"):
            b.cmake_version_prefix = a
        if o in ("-p", "--project_name"):
            b.project_name = a
        if o in ("-r", "--repository"):
            b.repository = a
        if o in ("-v", "--version"):
            version = a.split(".")
            try:
                b.version_maj = version[0]
                b.version_min = version[1]
            except:
                die("Invalid version format (maj.min): %s" % a)
        if o in ("-s", "--svn_path"):
            svn_path = a

    b.source_dir_rel = b.repository + "-source"

    svn_destdir = os.path.join("/tmp", b.source_dir_rel)

    svn_server = "slssvn"
    if svn_path.startswith("svn://"):
        b.svn_fullpath = svn_path
    else:
        b.svn_fullpath = "svn://%s/%s/%s/" % (svn_server, b.repository, svn_path)

    b.version_rev = getSvn_Release(b.svn_fullpath)
    b.version_date = getSvn_Date(b.svn_fullpath)
    b.init()
    b.printOptions()

    rpmbase_dir = os.path.join(os.getenv("HOME"), "rpmbuild")

    specdir = os.path.join(rpmbase_dir, "SPECS")
    if not os.path.exists(specdir):
        os.makedirs(specdir)

    b.svn_export(b.svn_fullpath, svn_destdir)
    b.clean_lts_cc_conf(svn_destdir + "/Lts/Projects")
    specname = b.specname(os.path.join(svn_destdir, "specs"))
    b.copy_spec(b.svn_fullpath, specdir, os.path.join(svn_destdir, "specs", specname))

    full_version = "%s.%s-%s" % (b.version_maj, b.version_min, b.version_rev)
    b.printOptions()

    b.pack_sources(svn_destdir, os.path.join(rpmbase_dir, "SOURCES"))
    removeDirectory(svn_destdir)
    exec_rpmbuild(specdir, specname)

    dstdir = os.path.join(
        b.output_dir, "%s-%s-%s" % (b.project_name, b.repository, full_version)
    )
    filter = re.compile("^.*%s\..*\.rpm$" % full_version)
    moved_files = moveFilesToDir(rpmbase_dir, dstdir, filter, True)

    if rpm_filelist != None:
        try:
            f = open(rpm_filelist, "w")
            for m in moved_files:
                f.write("%s\n" % m)
            f.close()
        except:
            die("Error creating fileslist %s" % rpm_filelist)


if __name__ == "__main__":
    main()