/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <iostream>
#include <algorithm>
#include <list>
#include <string>
#include <iterator>

#include "ignite/ignite_configuration.h"
#include "ignite/ignition.h"
#include "ignite/common/utils.h"

typedef std::list<std::string> StringList;
typedef std::set<std::string> StringSet;

namespace config
{
    using ignite::common::ToLower;

    /** Command line argument: Ignite home. */
    const std::string CmdIgniteHome = ToLower("-IgniteHome=");
    
    /** Command line argument: Spring config URL. */
    const std::string CmdSpringCfgUrl = ToLower("-SpringConfigUrl=");

    /** Command line argument: Path to JVM library. */
    const std::string CmdJvmLib = ToLower("-JvmLibPath=");

    /** Command line argument: JVM classpath. */
    const std::string CmdJvmClasspath = ToLower("-JvmClasspath=");

    /** Command line argument: JVM option prefix. */
    const std::string CmdJvmOpt = ToLower("-J");

    /** Command line argument: JvmInitialMemoryMB. */
    const std::string CmdJvmMinMem = ToLower("-JvmInitialMemoryMB=");

    /** Command line argument: JvmMaxMemoryMB. */
    const std::string CmdJvmMaxMem = ToLower("-JvmMaxMemoryMB=");

    /**
     * Convert configuration to arguments.
     *
     * @param cfg Input configuration.
     * @param args Output arguments.
     */
    void ToArgs(const ignite::IgniteConfiguration& cfg, StringList& args)
    {
        using ignite::common::LongToString;

        if (!cfg.igniteHome.empty())
            args.push_back(CmdIgniteHome + cfg.igniteHome);

        if (cfg.springCfgPath.empty())
            args.push_back(CmdSpringCfgUrl + cfg.springCfgPath);

        if (cfg.jvmLibPath.empty())
            args.push_back(CmdJvmLib + cfg.jvmLibPath);

        if (cfg.jvmClassPath.empty())
            args.push_back(CmdJvmClasspath + cfg.jvmClassPath);

        if (cfg.jvmOpts.empty())
        {
            for (StringList::const_iterator i = cfg.jvmOpts.begin(); i != cfg.jvmOpts.end(); ++i)
                args.push_back(CmdJvmOpt + *i);
        }

        args.push_back(CmdJvmMinMem + LongToString(cfg.jvmInitMem));
        args.push_back(CmdJvmMaxMem + LongToString(cfg.jvmMaxMem));
    }
    
    /**
     * Convert arguments to configuration.
     *
     * @param cfg Output configuration.
     * @param src Input arguments.
     */
    void Configure(ignite::IgniteConfiguration& cfg, const StringList& src)
    {
        using ignite::common::ParseInt;

        StringList jvmOpts;

        for (StringList::const_iterator i = src.begin(); i != src.end(); ++i)
        {
            const std::string& arg = *i;

            std::string argLow = ToLower(arg);

            if (argLow.find(CmdIgniteHome) == 0)
                cfg.igniteHome = arg.substr(CmdIgniteHome.size());
            else if (argLow.find(CmdSpringCfgUrl) == 0)
                cfg.springCfgPath = arg.substr(CmdSpringCfgUrl.size());
            else if (argLow.find(CmdJvmLib) == 0)
                cfg.jvmLibPath = arg.substr(CmdJvmLib.size());
            else if (argLow.find(CmdJvmClasspath) == 0)
                cfg.jvmClassPath = arg.substr(CmdJvmClasspath.size());
            else if (argLow.find(CmdJvmMinMem) == 0)
                cfg.jvmInitMem = ParseInt(arg.substr(CmdJvmMinMem.size()));
            else if (argLow.find(CmdJvmMaxMem) == 0)
                cfg.jvmMaxMem = ParseInt(arg.substr(CmdJvmMaxMem.size()));
            else if (argLow.find(CmdJvmOpt) == 0)
                jvmOpts.push_back(arg.substr(CmdJvmOpt.size()));
            else
            {
                std::cout << "WARNING: unknown argument \"" << arg << "\"."
                          << "Type --help for the list of supported arguments." << std::endl;
            }
        }

        if (!jvmOpts.empty())
        {
            if (!cfg.jvmOpts.empty())
                cfg.jvmOpts.swap(jvmOpts);
            else
                std::copy(jvmOpts.begin(), jvmOpts.end(), std::back_insert_iterator<StringList>(cfg.jvmOpts));
        }
    }
}


/**
 * Prints help to standard output.
 */
void PrintHelp()
{
    std::cout << "Usage: ignite [-options]" << std::endl;
    std::cout << std::endl;
    std::cout << "Options:" << std::endl;
    std::cout << "\t-igniteHome            path to Ignite installation directory (if not provided IGNITE_HOME environment variable is used)" << std::endl;
    std::cout << "\t-springConfigUrl       path to spring configuration file (if not provided \"config/default-config.xml\" is used)" << std::endl;
    std::cout << "\t-jvmLibPath            path to JVM library (if not provided JAVA_HOME environment variable is used)" << std::endl;
    std::cout << "\t-jvmClasspath          classpath passed to JVM (enlist additional jar files here)" << std::endl;
    std::cout << "\t-J<javaOption>         JVM options passed to created JVM" << std::endl;
    std::cout << "\t-jvmInitialMemoryMB    Initial Java heap size, in megabytes. Maps to -Xms Java parameter. Defaults to 512." << std::endl;
    std::cout << "\t-jvmMaxMemoryMB        Maximum Java heap size, in megabytes. Maps to -Xmx Java parameter. Defaults to 1024." << std::endl;
    std::cout << std::endl;
    std::cout << "Examples:" << std::endl;
    std::cout << "\tignite -J-Xms1024m -J-Xmx1024m -springConfigUrl=C:/woer/gg-test/my-test-gg-confignative.xml" << std::endl;
    std::cout << "\tignite -igniteHome=c:/apache-ignite -jvmClasspath=libs/myLib1.jar;libs/myLib2.jar" << std::endl;
    std::cout << "\tignite -jvmInitialMemoryMB=1024 -jvmMaxMemoryMB=4096" << std::endl;
    std::cout << std::endl;
}

/**
 * Application entry point.
 */
int main(int argc, const char* argv[])
{
    // Help commands.
    StringSet help;
    help.insert("/help");
    help.insert("-help");
    help.insert("--help");

    StringList args(argv + 1, argv + argc);

    try
    {
        // Check for special cases.
        if (!args.empty())
        {
            using ignite::common::ToLower;

            std::string first = ToLower(args.front());

            if (help.find(first) != help.end())
            {
                PrintHelp();

                return 0;
            }
        }

        // Pick application configuration.
        ignite::IgniteConfiguration cfg;

        // Pick command line arguments.
        config::Configure(cfg, args);

        ignite::Ignite ignite = ignite::Ignition::Start(cfg);

        ignite::impl::IgniteImpl *igniteImpl = ignite::impl::IgniteImpl::GetFromProxy(ignite);

        if (igniteImpl)
        {
            ignite::jni::java::JniContext* context = igniteImpl->GetContext();

            if (context)
                context->DestroyJvm();
        }
    }
    catch (const ignite::IgniteError& e)
    {
        std::cout << "ERROR: " << e.GetText() << std::endl;

        return -1;
    }
    catch (const std::exception& e)
    {
        std::cout << "ERROR: " << e.what() << std::endl;

        return -2;
    }

    return 0;
}