#include <fstream>
#include <stdexcept>
#include <cstring>
#include "Driver.h"
#include "MSVC/MSVCMapFileParser.h"
#include "Clang/ClangMapFileParser.h"
#include "SNC/SNCMapFileParser.h"
#include "GCC/GCCMapFileParser.h"
#include "SymbolInfoWriter.h"
#include "Statistics.h"

#ifdef _WINDOWS
#include <Windows.h>
#endif

namespace mapfileparser
{
    enum MapFileFormat
    {
        kMapFileFormatUnknown,
        kMapFileFormatMSVC,
        kMapFileFormatClang,
        kMapFileFormatSNC,
        kMapFileFormatGCC,
    };

    static MapFileParser* GetParser(MapFileFormat mapFileFormat)
    {
        switch (mapFileFormat)
        {
            case kMapFileFormatMSVC:
                return new MSVCMapFileParser();
            case kMapFileFormatClang:
                return new ClangMapFileParser();
            case kMapFileFormatSNC:
                return new SNCMapFileParser();
            case kMapFileFormatGCC:
                return new GCCMapFileParser();
            default:
                throw new std::runtime_error(std::string("Invalid map file format specified"));
        }
    }

    static const char* GetUsage()
    {
        return "Usage: MapFileParser -format=<MSVC|Clang|SNC|GCC> mapFile <-stats|outputFile>";
    }

    static std::string NativeStringToUtf8(const NativeChar* str)
    {
#if !_WINDOWS
        return str;
#else
        size_t strLength = wcslen(str);
        std::string result;
        result.resize(4 * strLength);

        int resultLength = WideCharToMultiByte(CP_UTF8, 0, str, static_cast<int>(strLength), &result[0], static_cast<int>(4 * strLength), NULL, NULL);
        result.resize(resultLength);
        return result;
#endif
    }

    static void ParseInputAndWriteOutput(MapFileFormat mapFileFormat, std::ifstream& inputFile, std::ofstream& outputFile)
    {
        MapFileParser* parser = GetParser(mapFileFormat);
        MapFile mapFile = parser->Parse(inputFile);

        SymbolInfoWriter::Write(outputFile, mapFile);
    }

    static void ParseInputAndGenerateStatistics(MapFileFormat mapFileFormat, std::ifstream& inputFile, std::ostream& output)
    {
        MapFileParser* parser = GetParser(mapFileFormat);
        MapFile mapFile = parser->Parse(inputFile);

        Statistics::Generate(mapFile, output);
    }

    int Driver::Run(int argc, const NativeChar* const argv[], std::ostream& out)
    {
        if (argc != 4)
        {
            out << GetUsage() << std::endl;
            return 1;
        }

        MapFileFormat mapFileFormat = kMapFileFormatUnknown;
        if (!NativeStrCmp(argv[1], NativeText("-format=MSVC")))
            mapFileFormat = kMapFileFormatMSVC;
        else if (!NativeStrCmp(argv[1], NativeText("-format=Clang")))
            mapFileFormat = kMapFileFormatClang;
        else if (!NativeStrCmp(argv[1], NativeText("-format=SNC")))
            mapFileFormat = kMapFileFormatSNC;
        else if (!NativeStrCmp(argv[1], NativeText("-format=GCC")))
            mapFileFormat = kMapFileFormatGCC;

        if (mapFileFormat == kMapFileFormatUnknown)
        {
            out << "Unknown map file format.\n";
            out << GetUsage() << std::endl;
            return 1;
        }

        // If we have a runtime error, like a file failing to open or an error parsing,
        // we want to return 0, so that the build will succeed. Since map-file based
        // stack traces are not required to execute, we won't fail the build if
        // we can't generate the output file.

        const NativeChar* mapFileName = argv[2];

        std::ifstream inputFile;
        inputFile.open(mapFileName, std::ifstream::in);
        if (!inputFile.is_open())
        {
            out << "Map file " << NativeStringToUtf8(argv[2]) << " cannot be opened.\n";
            return 1;
        }

        if (NativeStrCmp(argv[3], NativeText("-stats")) == 0)
        {
            if (mapFileFormat != kMapFileFormatClang)
            {
                out << "Statistics are only supported for Clang map files now.\n";
                out << GetUsage() << std::endl;
                return 1;
            }

            try
            {
                ParseInputAndGenerateStatistics(mapFileFormat, inputFile, out);
            }
            catch (const std::exception& e)
            {
                out << e.what() << std::endl;
            }
        }
        else
        {
            const NativeChar* outputFileName = argv[3];

            std::ofstream outputFile;
            outputFile.open(outputFileName, std::ios::binary | std::ios::out);
            if (!outputFile.is_open())
            {
                out << "Output file " << NativeStringToUtf8(argv[3]) << " cannot be opened.\n";
                return 0;
            }

            try
            {
                ParseInputAndWriteOutput(mapFileFormat, inputFile, outputFile);
            }
            catch (const std::exception& e)
            {
                out << e.what() << std::endl;
            }
        }

        return 0;
    }
}