#! /usr/bin/env python
# encoding: utf-8

import Task, Options, Utils, Logs, shutil, os.path
from TaskGen import extension

def set_options(opt):
    grp = opt.add_option_group("Guitarix Widget Library")
    grp.add_option('--shared-lib',
                   action='store_const',
                   default=False,
                   const=True,
                   help=('build shared library'),
                   )
    grp.add_option('--lib-dev',
                   action='store_const',
                   default=False,
                   const=True,
                   help=('install shared library headers'),
                   )
    grp.add_option('--no-ldconfig',
                   action='store_const',
                   default=False,
                   const=True,
                   help=('dont run ldconfig'),
                   )
    grp.add_option('--generate-cpp-wrapper',
                   action='store_const',
                   default=False,
                   const=True,
                   help=('re-generate the pre-built c++ library wrapper files (Developers only!!)'),
                   )

def configure(conf):
    conf.check_tool('misc')
    if Options.options.generate_cpp_wrapper:
        conf.cfg_get_variable(package='glibmm-2.4', variable='gmmprocdir')
        conf.cfg_get_variable(package='gtkmm-2.4', variable='gmmprocm4dir', prefix="GTK_")
        conf.cfg_get_variable(package='atkmm-1.6', variable='gmmprocm4dir', prefix="ATK_")
        conf.cfg_get_variable(package='pangomm-1.4', variable='gmmprocm4dir', prefix="PANGO_")
        conf.env["USE_GENERATED_CPP"] = False
    else:
        conf.env["USE_GENERATED_CPP"] = True
    if Options.options.shared_lib or not Options.options.no_lv2:
        conf.env["GX_LIB_SHARED"] = True
    else:
        conf.env["GX_LIB_STATIC"] = True
    if Options.options.lib_dev:
        conf.env["GX_LIB_SHARED"] = True
        conf.env["GX_LIB_DEV"] = True
        conf.env["GX_LIB_STATIC"] = False
    if Options.options.no_ldconfig:
        conf.env["NO_LDCONFIG"] = True


def template2cc(task):
    basename = os.path.splitext(
        os.path.basename(task.inputs[0].srcpath(task.env)))[0]
    srcdir = task.inputs[0].parent
    try:
        os.remove(task.outputs[0].bldpath(task.env))
    except OSError:
        pass
    try:
        os.mkdir(task.outputs[0].parent.bldpath(task.env) + "/private")
    except OSError:
        pass
    spath = srcdir.srcpath(task.env)
    dpath = srcdir.bldpath(task.env)
    cmd = ["%s/gmmproc" % task.env["GMMPROCDIR"],
           "--defs", dpath,
           "-I", spath,
           "-I", "%s" % task.env["GTK_GMMPROCM4DIR"],
           "-I", "%s" % task.env["ATK_GMMPROCM4DIR"],
           "-I", "%s" % task.env["PANGO_GMMPROCM4DIR"],
           basename,
           spath,
           dpath,
           ]
    Logs.debug("runner: system command -> %s" % cmd)
    ret = Utils.exec_command(cmd, shell=False)
    if ret != 0:
        return ret
    dpath += "/"
    spath += "/../gxwmm-generated/"
    try:
        shutil.copy2(dpath+basename+".cc", spath+basename+".cc")
        shutil.copy2(dpath+basename+".h", spath+basename+".h")
        shutil.copy2(dpath+"private/"+basename+"_p.h", spath+"private/"+basename+"_p.h")
    except (OSError, IOError) as e:
        Logs.error("runner: cannot copy file -> %s" % e)
        return e.errno
    return 0

Task.task_type_from_func(
    'gmmproc',
    template2cc,
    color='BLUE',
    before='cxx')

@extension('.hg')
def process_hg(self, node):
        cc_node = node.change_ext('.cc')
        task = self.create_task('gmmproc', [node], [cc_node])
        task.after = ["gxwdefs"]
        task.deps_nodes.append(
            node.parent.find_resource(node.name.replace('.hg','.ccg')))
        task.deps_nodes.append(
            node.parent.find_or_declare('gxw.defs'))
        self.allnodes.append(cc_node)

def header2defs(task):
    sources = " ".join(["'%s'" % v.srcpath(task.env) for v in task.inputs[1:]])
    path = task.generator.path
    dst = task.outputs[0].bldpath(task.env)
    flt = task.inputs[0].srcpath(task.env)
    cmd = ("python '%s'/h2def.py -f '%s' -m gxw %s > '%s'"
           % (task.env["CODEGENDIR"], flt, sources, dst))
    Logs.debug("runner: system command -> %s" % cmd)
    return Utils.exec_command(cmd, shell=True)

def build_generate_wrapper(bld):
    header = ["GxTuner.h",
              "GxRackTuner.h",
              "GxFastMeter.h",
              "GxWaveView.h",
              "GxRegler.h",
              "GxSelector.h",
              "GxSwitch.h",
              "GxToggleImage.h",
              "GxControlParameter.h",
              "GxIREdit.h",
              "GxRadioButton.h",
              "GxWheel.h",
              "GxWheelVertical.h",
              "GxKnob.h",
              "GxBigKnob.h",
              "GxSmallKnob.h",
              "GxSmallKnobR.h",
              "GxHSlider.h",
              "GxMiniSlider.h",
              "GxVSlider.h",
              "GxEQSlider.h",
              "GxLevelSlider.h",
              "GxPaintBox.h",
              "GxMeterScale.h",
              "GxGradient.h",
              "GxValueDisplay.h",
              "GxSimpleValueDisplay.h",
              "GxPortDisplay.h",
              ]
    header = ["../../libgxw/gxw/"+v for v in header]
    bld(features = ['cxx', 'cprogram'],
        source = "generate_defs_gxw.cc",
        includes = ["../../libgxw"],
        uselib = ['GTKMM'],
        lib    = 'glibmm_generate_extra_defs-2.4',
        uselib_local = "gxw",
        target = 'generate_defs_gxw',
        install_path = None,
        )
    bld.add_group()
    libdir = bld.path.find_dir("../../libgxw/gxw").bldpath(bld.env)
    e1 = 's/GdkEvent\\*/GdkEventButton*/'
    e2 = 's/return-type "const-gchar\\*"/return-type "gchar*"/'
    bld(name = "sigdefs",
        rule = ("LD_LIBRARY_PATH=\"%s\" ${SRC} | sed -e '"+e1+"' -e '"+e2+"'> ${TGT}") % libdir, #FIXME
        source = 'generate_defs_gxw',
        target = 'signals.defs',
        )
    bld(name = "mthdefs",
        rule = header2defs,
        source = ['filter.defs']+header,
        target = "methods.defs",
        )
    bld(name = "enumdefs",
        rule = bld.path.srcpath(bld.env)+"/enum.pl ${SRC} > ${TGT}",
        source = header,
        target = "enum.defs",
        )
    bld(name = "gxwdefs",
        rule = 'for f in ${SRC}; do echo "(include $(basename $f))"; done > ${TGT}',
        source = ["methods.defs","signals.defs","enum.defs"],
        target = "gxw.defs",
        after = ["sigdefs","mthdefs","enumdefs"],
        )
    bld(rule = "cp ${SRC} ${TGT}", 
        source = "docs.xml",
        target = "gxw_docs.xml",
        )

def build(bld):
    sources = [
        "controlparameter.hg",
        "switch.hg",
        "regler.hg",
        "knob.hg",
        "bigknob.hg",
        "smallknob.hg",
        "smallknobr.hg",
        "tuner.hg",
        "racktuner.hg",
        "fastmeter.hg",
        "waveview.hg",
        "selector.hg",
        "toggleimage.hg",
        "iredit.hg",
        "radiobutton.hg",
        "wheel.hg",
        "wheelvertical.hg",
        "hslider.hg",
        "minislider.hg",
        "vslider.hg",
        "eqslider.hg",
        "levelslider.hg",
        "paintbox.hg",
        "meterscale.hg",
        #"gradient.hg",
        "valuedisplay.hg",
        "simplevaluedisplay.hg",
        "portdisplay.hg",
        ]
    if bld.env["USE_GENERATED_CPP"]:
        gdir = "../gxwmm-generated/"
        for v in sources:
            s = v.replace(".hg", ".cc")
            bld(name = "copy-generated-cc",
                rule = "cp ${SRC} ${TGT}",
                source = gdir + s,
                target = s,
                )
            s = v.replace(".hg", ".h")
            bld(name = "copy-generated-h",
                rule = "cp ${SRC} ${TGT}",
                source = gdir + s,
                target = s,
                )
            s = v.replace(".hg", "_p.h")
            bld(name = "copy-generated-p-h",
                rule = "cp ${SRC} ${TGT}",
                source = gdir + "private/" + s,
                target = "private/" + s,
                )
        bld(name = "copy-wrap_init",
            rule = "cp ${SRC} ${TGT}",
            source = gdir + "wrap_init.cc",
            target = 'wrap_init.cc',
            )
        sources = [v.replace(".hg",".cc") for v in sources]
    else:
        bld(name = "wrap_init",
            rule = bld.env["GMMPROCDIR"]+"/generate_wrap_init.pl --namespace=Gxw ${SRC} >${TGT}; cp ${TGT} ../libgxwmm/gxwmm-generated", #FIXME
            source = sources,
            target = "wrap_init.cc",
            )
        build_generate_wrapper(bld)
    bld.add_group()
    if bld.env["GX_LIB_SHARED"]:
        bld(features = ['cxx', 'cshlib', 'libtool'],
            type = 'cshlib',
            vnum = "0.1",
            includes = ['..','../../libgxw'],
            source = sources+["init.cc","wrap_init.cc"],
            uselib = ['GTKMM'],
            uselib_local = ['gxw'],
            target = 'gxwmm',
            )
    else:
        bld(features = ['cxx', 'cstaticlib'],
            includes = ['..','../../libgxw'],
            #cxxflags = ['-fPIC'],
            source = sources+["init.cc","wrap_init.cc"],
            uselib = ['GTKMM'],
            target = 'gxwmm',
            )
