/********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.

Copyright (C) 2010 Rohan Prabhu <rohan@rohanprabhu.com>

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*********************************************************************/

#include "chelate.h"
#include "meta.h"

QList<KWin::Chelate::ChelateProxy*> KWin::Chelate::ChelateProxy::chMap;

/**
  * ChelateProxy | functions
  */

KWin::Chelate::ChelateProxy::ChelateProxy()
    {
    engine = 0;
    }

void KWin::Chelate::ChelateProxy::setEngine(QScriptEngine* _engine)
    {
    engine = _engine;
    }

void KWin::Chelate::ChelateProxy::setConnectors(QScriptValueList _connectors)
    {
    connectors = _connectors;
    }

void KWin::Chelate::ChelateProxy::setAction(QScriptValue _action)
    {
    action = _action;
    }

void KWin::Chelate::ChelateProxy::setEventStrings(QStringList _on)
    {
    on = _on;
    }

void KWin::Chelate::ChelateProxy::setFilter(QScriptValue _filter)
    {
    filter = _filter;
    }

void KWin::Chelate::ChelateProxy::setId(int _id)
    {
    id = _id;
    }

QScriptValue KWin::Chelate::ChelateProxy::getAction()
    {
    return action;
    }

QScriptValue KWin::Chelate::ChelateProxy::getFilter()
    {
    return filter;
    }

void KWin::Chelate::ChelateProxy::process(int index)
    {
    if(engine == 0)
        {
        return;
        }

    QScriptValue connector = connectors.at(index).property("connect");
    QScriptValue _scanner = engine->newFunction(KWin::Chelate::scanner, 0);
    _scanner.setData(engine->fromScriptValue<int>(id));
    QScriptValueList args;

    args<<_scanner;
    connector.call(connectors.at(index), args);
    }

void KWin::Chelate::ChelateProxy::processAll()
    {
    for(int i = 0; i<connectors.size(); i++)
        {
        process(i);
        }
    }
/** */
// END of ChelateProxy | functions
/** */

/**
  * KWin::Chelate | functions
  */

QScriptValue KWin::Chelate::scanner(QScriptContext* ctx, QScriptEngine* eng)
    {
    QScriptValue index = (ctx->callee()).data();
    KWin::Chelate::ChelateProxy* proxy = KWin::Chelate::ChelateProxy::chMap.at(index.toNumber());
    QScriptValue filter = proxy->getFilter();
    bool ret = (filter.call(QScriptValue(), ctx->argumentsObject())).toBool();

    if(ret == true)
        {
        QScriptValue action = proxy->getAction();
        action.call(QScriptValue(), ctx->argumentsObject());
        }

    return eng->undefinedValue();
    }

QScriptValue KWin::Chelate::rule(QScriptContext* ctx, QScriptEngine* eng)
    {
    ChelateProxy* proxy = new ChelateProxy();
    QScriptValue chRule = eng->newObject();
    QScriptValue ruleObj;

    if(ctx->argumentCount() > 0)
        {
        ruleObj = ctx->argument(0);
        }
    else
        {
        return eng->undefinedValue();
        }

    /**
      * First, process the events that are to be hooked on to
      */
    if(ruleObj.property("on").isValid() && !ruleObj.property("on").isUndefined())
        {
        QStringList eventStrings;
        QScriptValueList connectors;
        QScriptValueIterator it(ruleObj.property("on"));

        while (it.hasNext())
            {
            it.next();
            QScriptValue connector = (eng->globalObject()).property("workspace").property(it.value().toString());

            if(connector.isValid() && !connector.isUndefined())
                {
                eventStrings<<it.value().toString();
                connectors<<connector;
                }
            }

        proxy->setConnectors(connectors);
        proxy->setEventStrings(eventStrings);
        }

    /**
      * Then we have our filters.. the most daring part of KWin Scripting yet :)
      * Actually this is pretty simple here, but just wait to see
      * Chelate LazyLogic (tm)
      */
    if(ruleObj.property("filter").isValid() && !ruleObj.property("filter").isUndefined())
        {
        QScriptValue filter = ruleObj.property("filter");

        if(filter.isFunction())
            {
            proxy->setFilter(filter);
            }
        }

    if(ruleObj.property("action").isValid() && !ruleObj.property("action").isUndefined())
        {
        QScriptValue action = ruleObj.property("action");

        if(action.isFunction())
            {
            proxy->setAction(action);
            }
        }

    proxy->setEngine(eng);
    proxy->setId(KWin::Chelate::ChelateProxy::chMap.size());
    KWin::Chelate::ChelateProxy::chMap.append(proxy);
    proxy->processAll();
    return chRule;
    }

QScriptValue KWin::Chelate::publishChelate(QScriptEngine* eng)
    {
    QScriptValue temp = eng->newObject();
    temp.setProperty("rule", eng->newFunction(KWin::Chelate::rule, 1), QScriptValue::Undeletable);

    temp.setProperty("and", KWin::MetaScripting::getLazyLogicFunction(eng, "ll_and"), QScriptValue::Undeletable);
    temp.setProperty("or", KWin::MetaScripting::getLazyLogicFunction(eng, "ll_or"), QScriptValue::Undeletable);
    temp.setProperty("not", KWin::MetaScripting::getLazyLogicFunction(eng, "ll_not"), QScriptValue::Undeletable);

    temp.setProperty("equiv", eng->newFunction(KWin::Chelate::chelationEquivGen, 0), QScriptValue::Undeletable);
    temp.setProperty("regex", eng->newFunction(KWin::Chelate::chelationRegexGen, 0), QScriptValue::Undeletable);
    return temp;
    }

/**
  * Chelation functions. These functions are used to filter
  * the incoming clients.
  */

QScriptValue KWin::Chelate::chelationRegex(QScriptContext* ctx, QScriptEngine* eng)
    {
    QScriptValue key = ((ctx->callee()).data()).property("key");
    QScriptValue regex = ((ctx->callee()).data()).property("regex");
    QScriptValue post = ((ctx->callee()).data()).property("post");
    QRegExp re(regex.toString());

    if(!key.isUndefined() && !regex.isUndefined())
        {
        QScriptValue scCentral = ctx->argument(0);
        QScriptValue callBase = scCentral.property(key.toString());
        QString final = (callBase.isFunction())?((callBase.call(scCentral)).toString()):(callBase.toString());
        int pos = re.indexIn(final);

        if(post.isUndefined())
            {
            if(pos > -1)
                {
                return eng->toScriptValue<bool>(1);
                }
            else
                {
                return eng->toScriptValue<bool>(0);
                }
            }
        else
            {
            QScriptValueList args;
            QStringList list = re.capturedTexts();
            args<<eng->toScriptValue<QStringList>(re.capturedTexts());
            return eng->toScriptValue<bool>((post.call(QScriptValue(), args)).toBool());
            }
        }
    else
        {
        return eng->toScriptValue<bool>(0);
        }
    }

QScriptValue KWin::Chelate::chelationRegexGen(QScriptContext* ctx, QScriptEngine* eng)
    {
    QScriptValue func = eng->newFunction(chelationRegex, 0);
    QScriptValue data = eng->newObject();
    data.setProperty("key", ctx->argument(0));
    data.setProperty("regex", ctx->argument(1));
    data.setProperty("post", ctx->argument(2));
    func.setData(data);
    return func;
    }

QScriptValue KWin::Chelate::chelationEquiv(QScriptContext* ctx, QScriptEngine* eng)
    {
    QScriptValue key = ((ctx->callee()).data()).property("key");
    QScriptValue value = ((ctx->callee()).data()).property("value");

    if(!key.isUndefined() && !value.isUndefined())
        {
        QScriptValue scCentral = ctx->argument(0);
        QScriptValue callBase = scCentral.property(key.toString());
        QString final = (callBase.isFunction())?((callBase.call(scCentral)).toString()):(callBase.toString());

        return eng->toScriptValue<bool>(final.compare(value.toString(), Qt::CaseInsensitive) == 0);
        }
    else
        {
        return eng->toScriptValue<bool>(0);
        }
    }

QScriptValue KWin::Chelate::chelationEquivGen(QScriptContext* ctx, QScriptEngine* eng)
    {
    QScriptValue func = eng->newFunction(chelationEquiv, 0);
    QScriptValue data = eng->newObject();
    data.setProperty("key", ctx->argument(0));
    data.setProperty("value", ctx->argument(1));
    func.setData(data);
    return func;
    }
    
QScriptValue KWin::Chelate::chelationCheck(QScriptContext* ctx, QScriptEngine* eng)
   {
   Q_UNUSED(eng)
   QScriptValue key = ((ctx->callee()).data()).property("key");
   
   if(!key.isUndefined())
       {
       QScriptValue scCentral = ctx->argument(0);
       QScriptValue callBase = scCentral.property(key.toString());
       return (callBase.isFunction())?((callBase.call(scCentral)).toBool()):(callBase.toBool());
       }
       
   return eng->toScriptValue<bool>(0);
   }
    
QScriptValue KWin::Chelate::chelationCheckGen(QScriptContext* ctx, QScriptEngine* eng)
    {
    QScriptValue func = eng->newFunction(chelationCheck, 0);
    QScriptValue data = eng->newObject();
    data.setProperty("key", ctx->argument(0));
    func.setData(data);
    return func;
    }

/**                */
/** LazyLogic (tm) */
/**                */

QScriptValue KWin::Chelate::lazyLogicGenerate(QScriptContext* ctx, QScriptEngine* eng)
    {
    // Assume everything as necessary. If enough or wrong parameters
    // are provided, undefined values are used and then the function call
    // fails silently (it is non-fatal)
    QScriptValue type = (((ctx->callee()).data()).property("lazylogic_type"));
    QString typeString = type.toString();

    if(!((typeString == "ll_and") || (typeString == "ll_or") || (typeString == "ll_not") || (typeString == "ll_xor")))
        {
        return eng->undefinedValue();
        }

    QScriptValue func = eng->newFunction(KWin::Chelate::lazyLogic, 0);
    QScriptValue data = eng->newObject();
    data.setProperty("lazylogic_type", type);
    data.setProperty("lazylogic_operands", ctx->argumentsObject());
    func.setData(data);
    return func;
    }

QScriptValue KWin::Chelate::lazyLogic(QScriptContext* ctx, QScriptEngine* eng)
    {
    bool init;
    QString type = (((ctx->callee()).data()).property("lazylogic_type")).toString();
    QScriptValue operands = ((ctx->callee()).data()).property("lazylogic_operands");

    if(type == "ll_and")
        {
        init = 1;
        }
    else if(type == "ll_or")
        {
        init = 0;
        }
    else if(type == "ll_not")
        {
        QScriptValue current = operands.property("0");

        return !(current.isFunction())?((current.call(QScriptValue(), ctx->argumentsObject())).toBool()):(current.toBool());
        }
    else if(type == "ll_xor")
        {
        QScriptValue _current = operands.property("0");
        QScriptValue  current = operands.property("1");

        return (( current.isFunction())?(( current.call(QScriptValue(), ctx->argumentsObject())).toBool()): current.toBool() ^
                (_current.isFunction())?((_current.call(QScriptValue(), ctx->argumentsObject())).toBool()):_current.toBool()
               );
        }
    else
        {
        return eng->toScriptValue<bool>(0);
        }

    for(int i=0; i<operands.property("length").toNumber(); i++)
        {
        QScriptValue current = operands.property(QString::number(i));
        if(current.isFunction())
            {
            if(type == "ll_and")
                {
                init = init && (current.isFunction())?((current.call(QScriptValue(), ctx->argumentsObject())).toBool()):(current.toBool());
                }
            else if(type == "ll_or")
                {
                init = init || (current.isFunction())?((current.call(QScriptValue(), ctx->argumentsObject())).toBool()):(current.toBool());
                }
            }
        }

    return eng->toScriptValue<bool>(init);
    }

/** */
// END of KWin::Chelate | functions
/** */