//
//Copyright (C) 2015 LunarG, Inc.
//
//All rights reserved.
//
//Redistribution and use in source and binary forms, with or without
//modification, are permitted provided that the following conditions
//are met:
//
//    Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//
//    Redistributions in binary form must reproduce the above
//    copyright notice, this list of conditions and the following
//    disclaimer in the documentation and/or other materials provided
//    with the distribution.
//
//    Neither the name of 3Dlabs Inc. Ltd. nor the names of its
//    contributors may be used to endorse or promote products derived
//    from this software without specific prior written permission.
//
//THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
//"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
//LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
//FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
//COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
//BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
//LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
//CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
//LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
//ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
//POSSIBILITY OF SUCH DAMAGE.
//

#include <iostream>
#include <fstream>
#include <cstring>
#include <stdexcept>

#include "../SPIRV/SPVRemapper.h"

namespace {

    typedef unsigned int SpvWord;

    // Poor man's basename: given a complete path, return file portion.
    // E.g:
    //      Linux:  /foo/bar/test  -> test
    //      Win:   c:\foo\bar\test -> test
    // It's not very efficient, but that doesn't matter for our minimal-duty use.
    // Using boost::filesystem would be better in many ways, but want to avoid that dependency.

    // OS dependent path separator (avoiding boost::filesystem dependency)
#if defined(_WIN32)
    char path_sep_char() { return '\\'; }
#else
    char path_sep_char() { return '/';  }
#endif

    std::string basename(const std::string filename)
    {
        const size_t sepLoc = filename.find_last_of(path_sep_char());

        return (sepLoc == filename.npos) ? filename : filename.substr(sepLoc+1);
    }

    void errHandler(const std::string& str) {
        std::cout << str << std::endl;
        exit(5);
    }

    void logHandler(const std::string& str) {
        std::cout << str << std::endl;
    }

    // Read word stream from disk
    void read(std::vector<SpvWord>& spv, const std::string& inFilename, int verbosity)
    {
        std::ifstream fp;

        if (verbosity > 0)
            logHandler(std::string("  reading: ") + inFilename);

        spv.clear();
        fp.open(inFilename, std::fstream::in | std::fstream::binary);

        if (fp.fail())
            errHandler("error opening file for read: ");

        // Reserve space (for efficiency, not for correctness)
        fp.seekg(0, fp.end);
        spv.reserve(size_t(fp.tellg()) / sizeof(SpvWord));
        fp.seekg(0, fp.beg);

        while (!fp.eof()) {
            SpvWord inWord;
            fp.read((char *)&inWord, sizeof(inWord));

            if (!fp.eof()) {
                spv.push_back(inWord);
                if (fp.fail())
                    errHandler(std::string("error reading file: ") + inFilename);
            }
        }
    }

    void write(std::vector<SpvWord>& spv, const std::string& outFile, int verbosity)
    {
        if (outFile.empty())
            errHandler("missing output filename.");

        std::ofstream fp;

        if (verbosity > 0)
            logHandler(std::string("  writing: ") + outFile);

        fp.open(outFile, std::fstream::out | std::fstream::binary);

        if (fp.fail())
            errHandler(std::string("error opening file for write: ") + outFile);

        for (auto word : spv) {
            fp.write((char *)&word, sizeof(word));
            if (fp.fail())
                errHandler(std::string("error writing file: ") + outFile);
        }

        // file is closed by destructor
    }

    // Print helpful usage message to stdout, and exit
    void usage(const char* const name, const char* const msg = 0)
    {
        if (msg)
            std::cout << msg << std::endl << std::endl;

        std::cout << "Usage: " << std::endl;

        std::cout << "  " << basename(name)
            << " [-v[v[...]] | --verbose [int]]"
            << " [--map (all|types|names|funcs)]"
            << " [--dce (all|types|funcs)]"
            << " [--opt (all|loadstore)]"
            << " [--strip-all | --strip all | -s]" 
            << " [--do-everything]" 
            << " --input | -i file1 [file2...] --output|-o DESTDIR"
            << std::endl;

        std::cout << "  " << basename(name) << " [--version | -V]" << std::endl;
        std::cout << "  " << basename(name) << " [--help | -?]" << std::endl;

        exit(5);
    }

    // grind through each SPIR in turn
    void execute(const std::vector<std::string>& inputFile, const std::string& outputDir,
        int opts, int verbosity)
    {
        for (const auto& filename : inputFile) {
            std::vector<SpvWord> spv;
            read(spv, filename, verbosity);
            spv::spirvbin_t(verbosity).remap(spv, opts);

            const std::string outfile = outputDir + path_sep_char() + basename(filename);

            write(spv, outfile, verbosity);
        }

        if (verbosity > 0)
            std::cout << "Done: " << inputFile.size() << " file(s) processed" << std::endl;
    }

    // Parse command line options
    void parseCmdLine(int argc, char** argv, std::vector<std::string>& inputFile,
        std::string& outputDir,
        int& options,
        int& verbosity)
    {
        if (argc < 2)
            usage(argv[0]);

        verbosity  = 0;
        options    = spv::spirvbin_t::NONE;

        // Parse command line.
        // boost::program_options would be quite a bit nicer, but we don't want to
        // introduce a dependency on boost.
        for (int a=1; a<argc; ) {
            const std::string arg = argv[a];

            if (arg == "--output" || arg == "-o") {
                // Output directory
                if (++a >= argc)
                    usage(argv[0], "--output requires an argument");
                if (!outputDir.empty())
                    usage(argv[0], "--output can be provided only once");

                outputDir = argv[a++];

                // Remove trailing directory separator characters
                while (!outputDir.empty() && outputDir.back() == path_sep_char())
                    outputDir.pop_back();

            }
            else if (arg == "-vv")     { verbosity = 2; ++a; } // verbosity shortcuts
            else if (arg == "-vvv")    { verbosity = 3; ++a; } // ...
            else if (arg == "-vvvv")   { verbosity = 4; ++a; } // ...
            else if (arg == "-vvvvv")  { verbosity = 5; ++a; } // ...

            else if (arg == "--verbose" || arg == "-v") {
                ++a;
                verbosity = 1;

                if (a < argc) {
                    char* end_ptr = 0;
                    int verb = ::strtol(argv[a], &end_ptr, 10);
                    // If we have not read to the end of the string or
                    // the string contained no elements, then we do not want to
                    // store the value.
                    if (*end_ptr == '\0' && end_ptr != argv[a]) {
                        verbosity = verb;
                        ++a;
                    }
                }
            }
            else if (arg == "--version" || arg == "-V") {
                std::cout << basename(argv[0]) << " version 0.97 " << __DATE__ << " " << __TIME__ << std::endl;
                exit(0);
            } else if (arg == "--input" || arg == "-i") {
                // Collect input files
                for (++a; a < argc && argv[a][0] != '-'; ++a)
                    inputFile.push_back(argv[a]);
            } else if (arg == "--do-everything") {
                ++a;
                options = options | spv::spirvbin_t::DO_EVERYTHING;
            } else if (arg == "--strip-all" || arg == "-s") {
                ++a;
                options = options | spv::spirvbin_t::STRIP;
            } else if (arg == "--strip") {
                ++a;
                if (strncmp(argv[a], "all", 3) == 0) {
                    options = options | spv::spirvbin_t::STRIP;
                    ++a;
                }
            } else if (arg == "--dce") {
                // Parse comma (or colon, etc) separated list of things to dce
                ++a;
                for (const char* c = argv[a]; *c; ++c) {
                    if (strncmp(c, "all", 3) == 0) {
                        options = (options | spv::spirvbin_t::DCE_ALL);
                        c += 3;
                    } else if (strncmp(c, "*", 1) == 0) {
                        options = (options | spv::spirvbin_t::DCE_ALL);
                        c += 1;
                    } else if (strncmp(c, "funcs", 5) == 0) {
                        options = (options | spv::spirvbin_t::DCE_FUNCS);
                        c += 5;
                    } else if (strncmp(c, "types", 5) == 0) {
                        options = (options | spv::spirvbin_t::DCE_TYPES);
                        c += 5;
                    }
                }
                ++a;
            } else if (arg == "--map") {
                // Parse comma (or colon, etc) separated list of things to map
                ++a;
                for (const char* c = argv[a]; *c; ++c) {
                    if (strncmp(c, "all", 3) == 0) {
                        options = (options | spv::spirvbin_t::MAP_ALL);
                        c += 3;
                    } else if (strncmp(c, "*", 1) == 0) {
                        options = (options | spv::spirvbin_t::MAP_ALL);
                        c += 1;
                    } else if (strncmp(c, "types", 5) == 0) {
                        options = (options | spv::spirvbin_t::MAP_TYPES);
                        c += 5;
                    } else if (strncmp(c, "names", 5) == 0) {
                        options = (options | spv::spirvbin_t::MAP_NAMES);
                        c += 5;
                    } else if (strncmp(c, "funcs", 5) == 0) {
                        options = (options | spv::spirvbin_t::MAP_FUNCS);
                        c += 5;
                    }
                }
                ++a;
            } else if (arg == "--opt") {
                ++a;
                for (const char* c = argv[a]; *c; ++c) {
                    if (strncmp(c, "all", 3) == 0) {
                        options = (options | spv::spirvbin_t::OPT_ALL);
                        c += 3;
                    } else if (strncmp(c, "*", 1) == 0) {
                        options = (options | spv::spirvbin_t::OPT_ALL);
                        c += 1;
                    } else if (strncmp(c, "loadstore", 9) == 0) {
                        options = (options | spv::spirvbin_t::OPT_LOADSTORE);
                        c += 9;
                    }
                }
                ++a;
            } else if (arg == "--help" || arg == "-?") {
                usage(argv[0]);
            } else {
                usage(argv[0], "Unknown command line option");
            }
        }
    }

} // namespace


int main(int argc, char** argv)
{
    std::vector<std::string> inputFile;
    std::string              outputDir;
    int                      opts;
    int                      verbosity;

#ifdef use_cpp11
    // handle errors by exiting
    spv::spirvbin_t::registerErrorHandler(errHandler);

    // Log messages to std::cout
    spv::spirvbin_t::registerLogHandler(logHandler);
#endif

    if (argc < 2)
        usage(argv[0]);

    parseCmdLine(argc, argv, inputFile, outputDir, opts, verbosity);

    if (outputDir.empty())
        usage(argv[0], "Output directory required");

    std::string errmsg;

    // Main operations: read, remap, and write.
    execute(inputFile, outputDir, opts, verbosity);

    // If we get here, everything went OK!  Nothing more to be done.
}