/*

 *  The ManaPlus Client

 *  Copyright (C) 2013-2019  The ManaPlus Developers

 *  Copyright (C) 2019-2021  Andrei Karas

 *

 *  This file is part of The ManaPlus Client.

 *

 *  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

 *  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 "fs/files.h"

#include "fs/mkdir.h"

#if defined(ANDROID) || defined(__native_client__)

#include "fs/paths.h"

#include "fs/virtfs/fs.h"

#include "fs/virtfs/tools.h"

#include "fs/virtfs/list.h"

#endif  // defined(ANDROID) || defined(__native_client__)

#if defined(ANDROID) || defined(__native_client__)

#include "utils/foreach.h"

#endif  // defined(ANDROID) || defined(__native_client__)

#include "utils/checkutils.h"

#include "utils/stringutils.h"

#include <dirent.h>

#include <fstream>

#include <sys/stat.h>

#include "debug.h"

extern const char *dirSeparator;

#ifdef ANDROID

void Files::extractLocale()

{

    // in future need also remove all locales in local dir

    const std::string fileName2 = pathJoin(getenv("APPDIR"), "locale.zip");

    VirtFs::mountZip(fileName2, Append_false);

    const std::string localDir = std::string(getenv("APPDIR"));

    VirtFs::List *const rootDirs = VirtFs::enumerateFiles("locale");

    FOR_EACH (StringVectCIter, i, rootDirs->names)

    {

        const std::string dir = pathJoin("locale", *i);

        if (VirtFs::isDirectory(dir))

        {

            const std::string moFile = dir + "/LC_MESSAGES/manaplus.mo";

            if (VirtFs::exists((moFile)))

            {

                const std::string localFile = pathJoin(localDir, moFile);

                const std::string localDir2 = pathJoin(localDir,

                    dir,

                    "LC_MESSAGES");

                mkdir_r(localDir2.c_str());

                copyVirtFsFile(moFile, localFile);

            }

        }

    }

    VirtFs::freeList(rootDirs);

    VirtFs::unmountZip(fileName2);

    remove(fileName2.c_str());

}

#endif  // ANDROID

#if defined(ANDROID) || defined(__native_client__)

namespace

{

#ifdef ANDROID

    int mFilesCount = 0;

#endif  // ANDROID

    Files::CopyFileCallbackPtr mCallbackPtr = nullptr;

}  // namespace

void Files::setCopyCallBack(Files::CopyFileCallbackPtr callback)

{

    mCallbackPtr = callback;

}

void Files::copyVirtFsFile(const std::string &restrict inFile,

                           const std::string &restrict outFile)

{

    int size = 0;

    const char *const buf = VirtFs::loadFile(inFile, size);

    FILE *const file = fopen(outFile.c_str(), "w");

    fwrite(buf, 1, size, file);

    fclose(file);

    delete [] buf;

#ifdef ANDROID

    if (mCallbackPtr)

    {

        mCallbackPtr(mFilesCount);

        mFilesCount ++;

    }

#endif  // ANDROID

}

void Files::copyVirtFsDir(const std::string &restrict inDir,

                          const std::string &restrict outDir)

{

    mkdir_r(outDir.c_str());

    VirtFs::List *const files = VirtFs::enumerateFiles(inDir);

    FOR_EACH (StringVectCIter, i, files->names)

    {

        const std::string file = pathJoin(inDir, *i);

        const std::string outDir2 = pathJoin(outDir, *i);

        if (VirtFs::isDirectory(file))

            copyVirtFsDir(file, outDir2);

        else

            copyVirtFsFile(file, outDir2);

    }

    VirtFs::freeList(files);

}

#endif  // ANDROID __native_client__

                      const std::string &restrict dstName)

{

#if defined __native_client__

    FILE *srcFile = fopen(srcName.c_str(), "rb");

    if (srcFile == nullptr)

        return -1;

    FILE *dstFile = fopen(dstName.c_str(), "w+b");

    if (dstFile == nullptr)

    {

        fclose(srcFile);

        return -1;

    }

    const int chunkSize = 500000;

    char *buf = new char[chunkSize];

    size_t sz = 0;

    while ((sz = fread(buf, 1, chunkSize, srcFile)))

    {

        if (fwrite(buf, 1, sz, dstFile) != sz)

        {

            delete [] buf;

            fclose(srcFile);

            fclose(dstFile);

            ::remove(dstName.c_str());

            return -1;

        }

    }

    delete [] buf;

    fclose(srcFile);

    fclose(dstFile);

    if (!::remove(srcName.c_str()))

        return 0;

    return -1;

#else  // defined __native_client__

#endif  // defined __native_client__

}

                    const std::string &restrict dstName)

{

        return -1;

    {

    }

    {

        {

        }

    }

}

{

    struct stat statbuf;

#ifdef WIN32

    // in windows path\file.ext\ by default detected as exists

    // if file.ext is not directory, need return false

    const bool res = (stat(path.c_str(), &statbuf) == 0);

    if (res == false)

        return false;

    if ((findLast(path, "/") == true || findLast(path, "\\") == true) &&

        S_ISDIR(statbuf.st_mode) == 0)

    {

        return false;

    }

    return true;

#else  // WIN32

#endif  // WIN32

}

                              StringVect &lines)

{

    char line[501];

    {

            fileName.c_str())

        return false;

    }

    return true;

}

                         const std::string &restrict name,

                         const std::string &restrict text)

{

    {

        {

        }

        else

        {

                fileName.c_str())

        }

    }

{

    {

        {

        }

    }

}

                      std::string path,

                      const bool skipSymlinks A_WIN_UNUSED)

{

    {

        const dirent *next_file = nullptr;

        {

#ifndef WIN32

            {

                struct stat statbuf;

                {

                }

            }

#endif  // WIN32

        }

    }

}