#include <grp.h>
#include <luna/Sort.h>
#include <luna/StringBuilder.h>
#include <luna/Units.h>
#include <os/ArgumentParser.h>
#include <os/Directory.h>
#include <os/File.h>
#include <os/FileSystem.h>
#include <os/Mode.h>
#include <pwd.h>

void find_user_and_group(struct stat& st, StringView& owner, StringView& group)
{
    auto* pw = getpwuid(st.st_uid);
    if (!pw) owner = "???";
    else
        owner = pw->pw_name;

    auto* grp = getgrgid(st.st_gid);
    if (!grp) group = "???";
    else
        group = grp->gr_name;
}

int sort_name(const os::Directory::Entry* a, const os::Directory::Entry* b)
{
    return String::compare(&a->name, &b->name);
}

int sort_size(const os::Directory::Entry* a, const os::Directory::Entry* b)
{
    return (a->size < b->size) ? -1 : ((a->size == b->size) ? 0 : 1);
}

int sort_time(const os::Directory::Entry* a, const os::Directory::Entry* b)
{
    return (a->mtime < b->mtime) ? -1 : ((a->mtime == b->mtime) ? 0 : 1);
}

static int (*sort_function)(const os::Directory::Entry*, const os::Directory::Entry*) = sort_name;

int sort_reverse(const os::Directory::Entry* a, const os::Directory::Entry* b)
{
    int rc = sort_function(a, b);
    if (rc < 0) return 1;
    if (rc > 0) return -1;
    return 0;
}

static Result<String> entry_join(const Vector<os::Directory::Entry>& vec, StringView delim)
{
    if (vec.size() == 0) return String {};
    if (vec.size() == 1) return vec[0].name.clone();

    StringBuilder sb;
    TRY(sb.add(vec[0].name));

    for (usize i = 1; i < vec.size(); i++)
    {
        TRY(sb.add(delim));
        TRY(sb.add(vec[i].name));
    }

    return sb.string();
}

Result<int> luna_main(int argc, char** argv)
{
    StringView pathname;
    bool show_all { false };
    bool show_almost_all { false };
    bool long_list { false };
    bool human_readable { false };
    bool si { false };
    bool follow_symlink_args { false };
    bool one_per_line { false };
    bool list_directories { false };

    StringView sort_type { "name" };

    bool reverse_sort { false };

    bool should_sort { true };

    os::ArgumentParser parser;
    parser.add_description("List files contained in a directory (defaults to '.', the current directory)"_sv);
    parser.add_system_program_info("ls"_sv);
    parser.add_positional_argument(pathname, "directory"_sv, "."_sv);
    parser.add_switch_argument(show_all, 'a', "all"_sv, "also list hidden files (whose filename begins with a dot)"_sv);
    parser.add_switch_argument(show_almost_all, 'A', "almost-all"_sv, "list all files except '.' and '..'"_sv);
    parser.add_switch_argument(long_list, 'l', ""_sv, "use a long listing format"_sv);
    parser.add_switch_argument(human_readable, 'h', "human-readable"_sv,
                               "with -l, show human-readable sizes e.g. 2KiB, 6GiB"_sv);
    parser.add_switch_argument(si, ' ', "si"_sv, "same as -h, but show sizes in powers of 10"_sv);
    parser.add_switch_argument(follow_symlink_args, 'H', "dereference-args"_sv,
                               "follow symbolic links listed as arguments"_sv);
    parser.add_switch_argument(one_per_line, '1', ""_sv, "list one file per line"_sv);
    parser.add_switch_argument(list_directories, 'd', "directory"_sv, "list directories instead of their contents"_sv);
    parser.add_value_argument(sort_type, ' ', "sort"_sv, true, "sort by name, size or time"_sv);
    parser.add_switch_argument(reverse_sort, 'r', "reverse"_sv, "reverse order while sorting"_sv);
    parser.parse(argc, argv);

    Vector<os::Directory::Entry> files;
    int dirfd = AT_FDCWD;
    SharedPtr<os::Directory> dir;

    if (!long_list) follow_symlink_args = true;

    if (sort_type == "none"_sv) { should_sort = false; }
    else if (sort_type == "name"_sv) { sort_function = sort_name; }
    else if (sort_type == "size"_sv) { sort_function = sort_size; }
    else if (sort_type == "time"_sv) { sort_function = sort_time; }
    else
    {
        os::eprintln("%s: unknown sort type: %s", argv[0], sort_type.chars());
        return 1;
    }

    if (os::FileSystem::is_directory(pathname, follow_symlink_args) && !list_directories)
    {
        dir = TRY(os::Directory::open(pathname));
        dirfd = dir->fd();

        auto filter = os::Directory::Filter::Hidden;
        if (show_almost_all) filter = os::Directory::Filter::ParentAndBase;
        else if (show_all)
            filter = os::Directory::Filter::None;

        files = TRY(dir->list(filter));
    }
    else if (os::FileSystem::exists(pathname, follow_symlink_args))
    {
        struct stat st;
        TRY(os::FileSystem::stat(pathname, st, false));

        os::Directory::Entry entry = {
            .name = TRY(String::from_string_view(pathname)),
            .mode = st.st_mode,
            .size = (usize)st.st_size,
            .mtime = st.st_mtime,
        };

        TRY(files.try_append(move(entry)));
    }
    else
        return err(ENOENT);

    if (should_sort)
    {
        if (reverse_sort) sort(files.begin(), files.end(), sort_reverse);
        else
            sort(files.begin(), files.end(), sort_function);
    }

    if (!long_list)
    {
        auto list = TRY(entry_join(files, one_per_line ? "\n"_sv : " "_sv));
        if (!list.is_empty()) os::println("%s", list.chars());
    }
    else
    {
        for (const auto& file : files)
        {
            struct stat st;
            TRY(os::FileSystem::stat({ dirfd, file.name.view() }, st, false));

            auto link = TRY(os::FileSystem::readlink({ dirfd, file.name.view() }));

            StringView owner;
            StringView group;

            find_user_and_group(st, owner, group);

            char formatted_mode[11];
            os::format_mode(st.st_mode, formatted_mode);

            if (!human_readable && !si)
            {
                os::println("%s %u %4s %4s %10lu %s%s%s", formatted_mode, st.st_nlink, owner.chars(), group.chars(),
                            st.st_size, file.name.chars(), link.is_empty() ? "" : " -> ", link.chars());
            }
            else
            {
                auto size = TRY(to_dynamic_unit(st.st_size, 10, false, si ? Unit::SI : Unit::Binary, false));
                os::println("%s %u %4s %4s %6s %s%s%s", formatted_mode, st.st_nlink, owner.chars(), group.chars(),
                            size.chars(), file.name.chars(), link.is_empty() ? "" : " -> ", link.chars());
            }
        }
    }

    return 0;
}