#include "seafile/fs/seafile_store.hpp"

#include <sqlite_orm/sqlite_orm.h>
#include <string>
#include <vector>
#include <algorithm>
#include <format>

#include "seafile/api/account_info.hpp"
#include "seafile/api/repo_info.hpp"
#include "seafile/fs/storage/repo_entry.hpp"
#include "seafile/fs/storage/repo_info.hpp"
#include "util/application_path.hpp"
#include "util/string_util.hpp"

namespace seafile::fs
{
    using RepoEntry = storage::RepoEntry;
    using AccountInfo = api::AccountInfo;
    using RepoInfo = storage::RepoInfo;

    namespace
    {
        std::string normalizePath(std::string path)
        {
            std::ranges::replace(path, '\\', '/');
            while (path.size() > 1 && path.back() == '/')
            {
                path.pop_back();
            }
            return path.empty() ? "/" : path;
        }

        std::vector<std::string> splitPath(const std::string& path)
        {
            auto parts = shell::util::StringUtil::split(path, "/");
            std::erase(parts, "");
            return parts;
        }

        std::string joinPath(const std::vector<std::string>& parts, const size_t start)
        {
            std::string result;
            for (size_t i = start; i < parts.size(); ++i)
            {
                if (!result.empty())
                {
                    result += '/';
                }
                result += parts[i];
            }
            return result.empty() ? "/" : "/" + result;
        }

        std::string parentPath(const std::string& path)
        {
            if (path == "/")
            {
                return "/";
            }
            const auto pos = path.find_last_of('/');
            if (pos == std::string::npos || pos == 0)
            {
                return "/";
            }
            return path.substr(0, pos);
        }

        auto make_storage(const std::string& path)
        {
            // clang-format off
            return sqlite_orm::make_storage(path,
                sqlite_orm::make_table("account_info",
                        sqlite_orm::make_column("space_usage", &AccountInfo::space_usage),
                        sqlite_orm::make_column("avatar_url", &AccountInfo::avatar_url),
                        sqlite_orm::make_column("email", &AccountInfo::email, sqlite_orm::primary_key()),
                        sqlite_orm::make_column("name", &AccountInfo::name),
                        sqlite_orm::make_column("total", &AccountInfo::total),
                        sqlite_orm::make_column("usage", &AccountInfo::usage),
                        sqlite_orm::make_column("login_id", &AccountInfo::login_id),
                        sqlite_orm::make_column("department", &AccountInfo::department),
                        sqlite_orm::make_column("contact_email", &AccountInfo::contact_email),
                        sqlite_orm::make_column("institution", &AccountInfo::institution),
                        sqlite_orm::make_column("is_staff", &AccountInfo::is_staff),
                        sqlite_orm::make_column("file_updates_email_interval", &AccountInfo::file_updates_email_interval),
                        sqlite_orm::make_column("collaborate_email_interval", &AccountInfo::collaborate_email_interval)
                    ),
                    sqlite_orm::make_table("repo_info",
                        sqlite_orm::make_column("type", &RepoInfo::type),
                        sqlite_orm::make_column("id", &RepoInfo::id, sqlite_orm::primary_key()),
                        sqlite_orm::make_column("owner", &RepoInfo::owner),
                        sqlite_orm::make_column("name", &RepoInfo::name),
                        sqlite_orm::make_column("mtime", &RepoInfo::mtime),
                        sqlite_orm::make_column("size", &RepoInfo::size),
                        sqlite_orm::make_column("encrypted", &RepoInfo::encrypted),
                        sqlite_orm::make_column("root", &RepoInfo::root),
                        sqlite_orm::make_column("permission", &RepoInfo::permission),
                        sqlite_orm::make_column("modifier_email", &RepoInfo::modifier_email),
                        sqlite_orm::make_column("modifier_contact_email", &RepoInfo::modifier_contact_email),
                        sqlite_orm::make_column("modifier_name", &RepoInfo::modifier_name),
                        sqlite_orm::make_column("file_count", &RepoInfo::file_count),
                        sqlite_orm::make_column("head_commit_id", &RepoInfo::head_commit_id),
                        sqlite_orm::make_column("enc_version", &RepoInfo::enc_version),
                        sqlite_orm::make_column("salt", &RepoInfo::salt),
                        sqlite_orm::make_column("magic", &RepoInfo::magic),
                        sqlite_orm::make_column("random_key", &RepoInfo::random_key)
                    ),
                    sqlite_orm::make_index("idx_repo_entry_path", &RepoEntry::path),
                    sqlite_orm::make_table("repo_entry",
                        sqlite_orm::make_column("repo_id", &RepoEntry::repo_id),
                        sqlite_orm::make_column("type", &RepoEntry::type),
                        sqlite_orm::make_column("name", &RepoEntry::name),
                        sqlite_orm::make_column("path", &RepoEntry::path),
                        sqlite_orm::make_column("id", &RepoEntry::id),
                        sqlite_orm::make_column("mtime", &RepoEntry::mtime),
                        sqlite_orm::make_column("modifier_email", &RepoEntry::modifier_email),
                        sqlite_orm::make_column("size", &RepoEntry::size),
                        sqlite_orm::make_column("is_locked", &RepoEntry::is_locked),
                        sqlite_orm::make_column("lock_owner", &RepoEntry::lock_owner),
                        sqlite_orm::make_column("lock_time", &RepoEntry::lock_time),
                        sqlite_orm::make_column("locked_by_me", &RepoEntry::locked_by_me),
                        sqlite_orm::make_column("permission", &RepoEntry::permission),
                        sqlite_orm::make_column("modifier_contact_email", &RepoEntry::modifier_contact_email),
                        sqlite_orm::make_column("modifier_name", &RepoEntry::modifier_name),
                        sqlite_orm::make_column("starred", &RepoEntry::starred),
                        sqlite_orm::primary_key(&RepoEntry::repo_id, &RepoEntry::path)
                    )
            );
            //clang-format on
        }
    }

    struct SeafileStore::Database
    {
        using Storage = decltype(make_storage(""));
        Storage storage;
        std::recursive_mutex mutex;

        explicit Database(const std::string& path)
            : storage(make_storage(path))
        {
            storage.pragma.journal_mode(sqlite_orm::journal_mode::WAL);
            storage.pragma.synchronous(1);
        }
    };

    tl::expected<void, api::SeafileException> SeafileStore::auth()
    {
        const auto auth_info = this->api.auth(this->username, this->password);
        if (auth_info)
        {
            return {};
        }
        return tl::make_unexpected(api::SeafileException(auth_info.error()));
    }

    SeafileStore::SeafileStore(const std::string& db_path, const std::string& server, const std::string& user,
                               const std::string& password) : api(server)
    {
        this->database = std::make_unique<Database>(db_path);
        this->username = user;
        this->password = password;
        this->api_server = server;
    }

    tl::expected<RepoEntry, api::SeafileException> SeafileStore::findRepoEntry(
        const std::string& repo_id, const std::string& path)
    {
        std::lock_guard lock(database->mutex);
        auto& storage = this->database->storage;
        const auto entries = storage.get_all<RepoEntry>(
            sqlite_orm::where(
                sqlite_orm::and_(
                    sqlite_orm::c(&RepoEntry::repo_id) == repo_id,
                    sqlite_orm::c(&RepoEntry::path) == path
                )
            ));
        if (!entries.empty())
        {
            return entries.at(0);
        }
        return tl::make_unexpected(api::SeafileException("entry not exists"));
    }


    tl::expected<bool, api::SeafileException> SeafileStore::checkIsUpdated(const std::string& repo_id)
    {
        std::lock_guard lock(database->mutex);
        auto& storage = this->database->storage;
        const auto repos = storage.get_all<RepoInfo>(
            sqlite_orm::where(
                sqlite_orm::c(&RepoInfo::id) == repo_id
            ));
        if (repos.empty())
        {
            return false;
        }
        const auto& repo = repos.at(0);
        const auto& commit_id = repo.head_commit_id;
        const auto repo_info = this->api.repoInfo(repo_id);
        if (repo_info)
        {
            return repo_info.value().head_commit_id == commit_id;
        }

        return tl::make_unexpected(repo_info.error());
    }

    tl::expected<void, api::SeafileException> SeafileStore::checkAndSync(const std::string& repo_id)
    {
        const auto is_updated = this->checkIsUpdated(repo_id);
        if (!is_updated)
        {
            return tl::make_unexpected(is_updated.error());
        }
        if (!is_updated.value())
        {
            try
            {
                {
                    std::lock_guard lock(database->mutex);
                    auto& storage = this->database->storage;
                    storage.remove_all<RepoEntry>(sqlite_orm::where(
                            sqlite_orm::c(&RepoEntry::repo_id) == repo_id
                        )
                    );
                }
                const auto repo_entries = this->api.repoDir(repo_id, "/");
                if (!repo_entries)
                {
                    return tl::make_unexpected(repo_entries.error());
                }
                {
                    std::lock_guard lock(database->mutex);
                    auto& storage = this->database->storage;
                    std::vector<RepoEntry> entries;
                    entries.reserve(repo_entries->size());
                    std::transform(repo_entries->begin(), repo_entries->end(), std::back_inserter(entries),
                                   [&repo_id](const auto& entry)
                                   {
                                       return RepoEntry::from_api_model(repo_id, "/", entry);
                                   });
                    storage.transaction([&entries,&storage]
                    {
                        storage.replace_range(entries.begin(), entries.end());
                        return true;
                    });
                }
            }
            catch (std::exception& e)
            {
                return tl::make_unexpected(api::SeafileException(e.what()));
            }
        }
        return {};
    }

    tl::expected<void, api::SeafileException> SeafileStore::init()
    {
        try
        {
            std::lock_guard lock(database->mutex);
            this->database->storage.sync_schema();
        }
        catch (std::exception& e)
        {
            return tl::make_unexpected(api::SeafileException(e.what()));
        }
        if (const auto auth_token = this->auth(); !auth_token)
        {
            return tl::make_unexpected(auth_token.error());
        }
        return this->sync();
    }

    tl::expected<void, api::SeafileException> SeafileStore::syncUserInfo()
    {
        const auto user_info = this->api.accountInfo();
        if (!user_info)
        {
            return tl::make_unexpected(user_info.error());
        }
        std::lock_guard lock(database->mutex);
        this->database->storage.replace(*user_info);
        return {};
    }

    tl::expected<std::vector<RepoInfo>, api::SeafileException> SeafileStore::syncRepos()
    {
        const auto repos = this->api.repos("mine", "");
        if (!repos)
        {
            return tl::make_unexpected(repos.error());
        }
        std::lock_guard lock(database->mutex);
        auto& storage = this->database->storage;
        std::vector<RepoInfo> result;
        result.reserve(repos->size());
        for (const auto& repo : *repos)
        {
            const auto storage_repo = RepoInfo::from_api_model(repo);
            result.push_back(storage_repo);
            try
            {
                const auto existings = storage.get_all<RepoInfo>(
                    sqlite_orm::where(sqlite_orm::c(&RepoInfo::id) == storage_repo.id));
                std::optional<RepoInfo> existing = std::nullopt;
                if (!existings.empty())
                {
                    existing = existings.at(0);
                }
                if (existing && existing->head_commit_id != storage_repo.head_commit_id)
                {
                    storage.remove_all<RepoEntry>(sqlite_orm::where(
                        sqlite_orm::c(&RepoEntry::repo_id) == storage_repo.id));
                }
                storage.replace(storage_repo);
            }
            catch (std::exception& e)
            {
                return tl::make_unexpected(api::SeafileException(e.what()));
            }
        }
        return result;
    }

    tl::expected<RepoInfo, api::SeafileException> SeafileStore::findRepoByName(const std::string& name)
    {
        try
        {
            std::vector<RepoInfo> repos;
            {
                std::lock_guard lock(database->mutex);
                auto& storage = this->database->storage;
                repos = storage.get_all<RepoInfo>(
                    sqlite_orm::where(sqlite_orm::c(&RepoInfo::name) == name));
            }
            if (!repos.empty())
            {
                return repos.at(0);
            }
            // if (const auto synced = this->syncRepos(); synced)
            // {
            //     std::lock_guard lock(database->mutex);
            //     auto& storage = this->database->storage;
            //     repos = storage.get_all<RepoInfo>(
            //         sqlite_orm::where(sqlite_orm::c(&RepoInfo::name) == name));
            //     if (!repos.empty())
            //     {
            //         return repos.at(0);
            //     }
            // }
            // else
            // {
            //     return tl::make_unexpected(synced.error());
            // }
        }
        catch (const std::exception& e)
        {
            return tl::make_unexpected(api::SeafileException(e.what()));
        }
        return tl::make_unexpected(api::SeafileException(std::format("repo not found: {}", name)));
    }

    tl::expected<void, api::SeafileException> SeafileStore::fetchAndStoreRepoDir(
        const std::string& repo_id, const std::string& parent_path)
    {
        const auto entries = this->api.repoDir(repo_id, parent_path);
        if (!entries)
        {
            return tl::make_unexpected(entries.error());
        }
        try
        {
            std::vector<RepoEntry> repo_entries;
            repo_entries.reserve(entries->size());
            std::transform(entries->begin(), entries->end(), std::back_inserter(repo_entries),
                           [&repo_id,&parent_path](const auto& entry)
                           {
                               return RepoEntry::from_api_model(repo_id, parent_path, entry);
                           });
            std::lock_guard lock(database->mutex);
            auto& storage = this->database->storage;
            constexpr std::size_t batch_size = 500;
            storage.transaction([&]
            {
                for (auto it = repo_entries.begin(); it != repo_entries.end();)
                {
                    auto end = it;
                    std::advance(end, std::min(batch_size,static_cast<std::size_t>(std::distance(it, repo_entries.end()))));

                    storage.replace_range(it, end);

                    it = end;
                }
                return true;
            });
        }
        catch (std::exception& e)
        {
            return tl::make_unexpected(api::SeafileException(e.what()));
        }
        return {};
    }

    std::vector<RepoEntry> SeafileStore::queryDirectoryChildren(
        const std::string& repo_id, const std::string& parent_path)
    {
        std::lock_guard lock(database->mutex);
        auto& storage = this->database->storage;
        const std::string prefix = (parent_path == "/") ? "" : parent_path;
        const auto all = storage.get_all<RepoEntry>(
            sqlite_orm::where(
                sqlite_orm::and_(
                    sqlite_orm::c(&RepoEntry::repo_id) == repo_id,
                    sqlite_orm::like(&RepoEntry::path, prefix + "/%")
                )
            ),sqlite_orm::order_by(&RepoEntry::name));
        std::vector<RepoEntry> children;
        for (auto& entry : all)
        {
            if (const auto rest = entry.path.substr(prefix.size() + 1); rest.find('/') == std::string::npos)
            {
                children.push_back(entry);
            }
        }
        return children;
    }

    tl::expected<std::variant<RepoInfo, RepoEntry>, api::SeafileException> SeafileStore::pathInfo(
        const std::string& path)
    {
        const auto normalized = normalizePath(path);
        const auto parts = splitPath(normalized);
        if (parts.empty())
        {
            return tl::make_unexpected(api::SeafileException("pathInfo does not support root path"));
        }

        const auto& repo_name = parts[0];
        const auto repo = findRepoByName(repo_name);
        if (!repo)
        {
            return tl::make_unexpected(repo.error());
        }

        if (parts.size() == 1)
        {
            return std::variant<RepoInfo, RepoEntry>(*repo);
        }

        const auto inner_path = joinPath(parts, 1);
        auto entry = findRepoEntry(repo->id, inner_path);
        if (entry)
        {
            return std::variant<RepoInfo, RepoEntry>(*entry);
        }

        const auto parent_path = parentPath(inner_path);
        if (const auto res = fetchAndStoreRepoDir(repo->id, parent_path); !res)
        {
            return tl::make_unexpected(res.error());
        }

        entry = findRepoEntry(repo->id, inner_path);
        if (entry)
        {
            return std::variant<RepoInfo, RepoEntry>(*entry);
        }
        return tl::make_unexpected(api::SeafileException(std::format("path not found: {}", path)));
    }

    tl::expected<std::variant<std::vector<RepoInfo>, std::vector<RepoEntry>>, api::SeafileException>
    SeafileStore::listDir(const std::string& path)
    {
        const auto normalized = normalizePath(path);
        const auto parts = splitPath(normalized);

        if (parts.empty())
        {
            std::lock_guard lock(database->mutex);
            auto& storage = this->database->storage;
            auto repos = storage.get_all<RepoInfo>(sqlite_orm::order_by(&RepoInfo::id));
            if (repos.empty())
            {
                if (const auto synced = this->syncRepos(); synced)
                {
                    repos = storage.get_all<RepoInfo>();
                }
                else
                {
                    return tl::make_unexpected(synced.error());
                }
            }
            return std::variant<std::vector<RepoInfo>, std::vector<RepoEntry>>(std::move(repos));
        }

        const auto& repo_name = parts[0];
        const auto repo = findRepoByName(repo_name);
        if (!repo)
        {
            return tl::make_unexpected(repo.error());
        }

        const auto inner_path = joinPath(parts, 1);
        auto children = queryDirectoryChildren(repo->id, inner_path);
        if (children.empty())
        {
            if (const auto res = fetchAndStoreRepoDir(repo->id, inner_path); !res)
            {
                return tl::make_unexpected(res.error());
            }
            children = queryDirectoryChildren(repo->id, inner_path);
        }
        return std::variant<std::vector<RepoInfo>, std::vector<RepoEntry>>(std::move(children));
    }

    tl::expected<std::string, api::SeafileException> SeafileStore::readFile(
        const std::string& repo_id, const std::string& path, const size_t offset, const size_t length) const
    {
        if (length == 0)
        {
            return std::string{};
        }
        return this->api.downloadFile(repo_id, path, offset, offset + length - 1);
    }

    tl::expected<api::AccountInfo, api::SeafileException> SeafileStore::accountInfo() const
    {
        std::lock_guard lock(database->mutex);
        auto& storage = this->database->storage;
        if (const auto infos = storage.get_all<AccountInfo>(); !infos.empty())
        {
            return infos.front();
        }
        return tl::make_unexpected(api::SeafileException("account info not synced"));
    }

    tl::expected<void, api::SeafileException> SeafileStore::sync()
    {
        if (const auto sync_account = this->syncUserInfo(); !sync_account)
        {
            return tl::make_unexpected(sync_account.error());
        }
        if (const auto sync_repos = syncRepos(); !sync_repos)
        {
            return tl::make_unexpected(sync_repos.error());
        }
        return {};
    }

    SeafileStore::~SeafileStore() = default;

    std::filesystem::path SeafileStore::storePath()
    {
        return shell::util::ApplicationPath::get().parent_path() / "seafile.sqlite";
    }
}