// NetFSServerPrefs.cpp

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <Application.h>
#include <Message.h>

#include "NetFSServerRoster.h"
#include "Permissions.h"

// simplified permissions
static const uint32 kMountPermission = MOUNT_SHARE_PERMISSION;
static const uint32 kQueryPermission = QUERY_SHARE_PERMISSION;
static const uint32 kReadPermission
        = READ_PERMISSION | READ_DIR_PERMISSION | RESOLVE_DIR_ENTRY_PERMISSION;
static const uint32 kWritePermission
        = WRITE_PERMISSION | WRITE_DIR_PERMISSION;

// usage
static const char* kUsage =
"Usage: netfs_server_prefs -h | --help\n"
"       netfs_server_prefs <command>\n"
"options:\n"
"  -h, --help        - print this text\n"
"\n"
"commands:\n"
"  launch\n"
"      launches the server\n"
"  terminate\n"
"      terminates the server\n"
"  save\n"
"      saves the server settings\n"
"  l, list\n"
"      list all users and all shares\n"
"  add share <name> <path>\n"
"      add a new share with the name <name> and path <path>\n"
"  remove share <name>\n"
"      remove the share named <name>\n"
"  add user <name> [ <password> ]\n"
"      add a new user with the name <name> and, if supplied, \n"
"      password <password>\n"
"  remove user <name>\n"
"      remove the user named <name>\n"
"  permissions <user> <share> [ m ] [ r ] [ w ] [ q ]\n"
"      set the permissions of user <user> for share <share> to m(ount),\n"
"      r(ead), w(rite), and/or q(uery).\n"
;

// print_usage
static
void
print_usage(bool error)
{
        fputs(kUsage, (error ? stderr : stdout));
}

// print_usage_and_exit
static
void
print_usage_and_exit(bool error)
{
        print_usage(error);
        exit(error ? 1 : 0);
}

// get_permissions_string
static
void
get_permissions_string(uint32 permissions, char* str)
{
        str[0] = (permissions & kMountPermission ? 'm' : '-');
        str[1] = (permissions & kReadPermission ? 'r' : '-');
        str[2] = (permissions & kWritePermission ? 'w' : '-');
        str[3] = (permissions & kQueryPermission ? 'q' : '-');
        str[4] = '\0';
}

// get_permissions
static
bool
get_permissions(const char* str, uint32* permissions)
{
        *permissions = 0;

        if (!str)
                return true;

        while (*str) {
                switch (*str) {
                        case 'm':
                                *permissions |= kMountPermission;
                                break;
                        case 'r':
                                *permissions |= kReadPermission;
                                break;
                        case 'w':
                                *permissions |= kWritePermission;
                                break;
                        case 'q':
                                *permissions |= kQueryPermission;
                                break;
                        default:
                                return false;
                }
                str++;
        }

        return true;
}

// assert_server_running
static
void
assert_server_running()
{
        // check, if the server is running
        NetFSServerRoster roster;
        if (!roster.IsServerRunning()) {
                fprintf(stderr, "Server is not running.\n");
                exit(1);
        }
}

// list
static
void
list()
{
        assert_server_running();

        NetFSServerRoster roster;

        // get the users
        BMessage users;
        status_t error = roster.GetUsers(&users);
        if (error == B_OK) {
                // list the users
                printf("users\n");
                printf("-----\n");
                const char* user;
                for (int32 i = 0; users.FindString("users", i, &user) == B_OK; i++)
                        printf("%s\n", user);
                printf("\n");
        } else
                fprintf(stderr, "Failed to get users: %s\n", strerror(error));

        // get the shares
        BMessage shares;
        error = roster.GetShares(&shares);
        if (error == B_OK) {
                // list the shares
                printf("shares\n");
                printf("------\n");
                const char* share;
                for (int32 i = 0; shares.FindString("shares", i, &share) == B_OK; i++) {
                        // get path
                        const char* path;
                        if (shares.FindString("paths", i, &path) != B_OK)
                                path = "<invalid path>\n";

                        // get share users
                        BMessage shareUsers;
                        roster.GetShareUsers(share, &shareUsers);

                        // get statistics
                        BMessage statistics;
                        roster.GetShareStatistics(share, &statistics);

                        printf("%s:\n", share);
                        printf("  path:         %s\n", path);

                        // print permitted users
                        printf("  mountable by: ");
                        const char* user;
                        for (int32 k = 0;
                                 shareUsers.FindString("users", k, &user) == B_OK;
                                 k++) {
                                if (k > 0)
                                        printf(", ");
                                printf("%s", user);

                                // print permissions
                                uint32 permissions = 0;
                                roster.GetUserPermissions(share, user, &permissions);
                                char permissionsString[8];
                                get_permissions_string(permissions, permissionsString);
                                printf(" (%s)", permissionsString);
                        }
                        printf("\n");

                        // print current users
                        printf("  mounted by:   ");
                        for (int32 k = 0;
                                 statistics.FindString("mounted by", k, &user) == B_OK;
                                 k++) {
                                if (k > 0)
                                        printf(", ");
                                printf("%s", user);
                        }
                        printf("\n");

                        printf("\n");
                }
        } else
                fprintf(stderr, "Failed to get users: %s\n", strerror(error));
}

// add_share
static
void
add_share(const char* name, const char* path)
{
        assert_server_running();

        NetFSServerRoster roster;

        // check whether a share with the given name already exists
        BMessage statistics;
        if (roster.GetShareStatistics(name, &statistics) == B_OK) {
                fprintf(stderr, "A share `%s' does already exist.\n", name);
                exit(1);
        }

        // add the share
        status_t error = roster.AddShare(name, path);
        if (error != B_OK) {
                fprintf(stderr, "Failed to add share: %s\n", strerror(error));
                exit(1);
        }
}

// remove_share
static
void
remove_share(const char* name)
{
        assert_server_running();

        NetFSServerRoster roster;

        // check whether a share with the given name exists
        BMessage statistics;
        if (roster.GetShareStatistics(name, &statistics) != B_OK) {
                fprintf(stderr, "A share `%s' does not exist.\n", name);
                exit(1);
        }

        // remove the share
        status_t error = roster.RemoveShare(name);
        if (error != B_OK) {
                fprintf(stderr, "Failed to remove share: %s\n", strerror(error));
                exit(1);
        }
}

// add_user
static
void
add_user(const char* name, const char* password)
{
        assert_server_running();

        NetFSServerRoster roster;

        // check whether a user with the given name already exists
        BMessage statistics;
        if (roster.GetUserStatistics(name, &statistics) == B_OK) {
                fprintf(stderr, "A user `%s' does already exist.\n", name);
                exit(1);
        }

        // add the user
        status_t error = roster.AddUser(name, password);
        if (error != B_OK) {
                fprintf(stderr, "Failed to add user: %s\n", strerror(error));
                exit(1);
        }
}

// remove_user
static
void
remove_user(const char* name)
{
        assert_server_running();

        NetFSServerRoster roster;

        // check whether a user with the given name exists
        BMessage statistics;
        if (roster.GetUserStatistics(name, &statistics) != B_OK) {
                fprintf(stderr, "A user `%s' does not exist.\n", name);
                exit(1);
        }

        // remove the user
        status_t error = roster.RemoveUser(name);
        if (error != B_OK) {
                fprintf(stderr, "Failed to remove user: %s\n", strerror(error));
                exit(1);
        }
}

// set_user_permissions
static
void
set_user_permissions(const char* user, const char* share, uint32 permissions)
{
        assert_server_running();

        NetFSServerRoster roster;

        // check whether a user with the given name exists
        BMessage statistics;
        if (roster.GetUserStatistics(user, &statistics) != B_OK) {
                fprintf(stderr, "A user `%s' does not exist.\n", user);
                exit(1);
        }

        // check whether a share with the given name exists
        if (roster.GetShareStatistics(share, &statistics) != B_OK) {
                fprintf(stderr, "A share `%s' does not exist.\n", share);
                exit(1);
        }

        // set the permissions
        status_t error = roster.SetUserPermissions(share, user, permissions);
        if (error != B_OK) {
                fprintf(stderr, "Failed to set permissions: %s\n", strerror(error));
                exit(1);
        }
}

// launch_server
static
void
launch_server()
{
        NetFSServerRoster roster;

        if (roster.IsServerRunning()) {
                fprintf(stderr, "Server is already running.\n");
                exit(1);
        }

        status_t error = roster.LaunchServer();
        if (error != B_OK) {
                fprintf(stderr, "Failed to launch server: %s\n", strerror(error));
                exit(1);
        }
}

// terminate_server
static
void
terminate_server()
{
        assert_server_running();

        NetFSServerRoster roster;

        status_t error = roster.TerminateServer();
        if (error != B_OK) {
                fprintf(stderr, "Failed to terminate server: %s\n", strerror(error));
                exit(1);
        }
}

// save_server_setttings
static
void
save_server_setttings()
{
        assert_server_running();

        NetFSServerRoster roster;

        status_t error = roster.SaveServerSettings();
        if (error != B_OK) {
                fprintf(stderr, "Failed to save settings: %s\n", strerror(error));
                exit(1);
        }
}

// next_arg
static
const char*
next_arg(int argc, char** argv, int& argi, bool dontFail = false)
{
        if (argi >= argc) {
                if (dontFail)
                        return NULL;
                print_usage_and_exit(true);
        }

        return argv[argi++];
}

// no_more_args
static
void
no_more_args(int argc, int argi)
{
        if (argi < argc)
                print_usage_and_exit(true);
}

// main
int
main(int argc, char** argv)
{
        BApplication app("application/x-vnd.haiku-netfs_server_prefs");

        // parse first argument
        int argi = 1;
        const char* arg = next_arg(argc, argv, argi);
        if (strcmp(arg, "-h") == 0 || strcmp(arg, "--help") == 0)
                print_usage_and_exit(false);

        if (strcmp(arg, "launch") == 0) {
                // launch
                no_more_args(argc, argi);
                launch_server();
        } else if (strcmp(arg, "terminate") == 0) {
                // terminate
                no_more_args(argc, argi);
                terminate_server();
        } else if (strcmp(arg, "save") == 0) {
                // save
                no_more_args(argc, argi);
                save_server_setttings();
        } else if (strcmp(arg, "l") == 0 || strcmp(arg, "list") == 0) {
                // list
                no_more_args(argc, argi);
                list();
        } else if (strcmp(arg, "add") == 0) {
                // add
                arg = next_arg(argc, argv, argi);
                if (strcmp(arg, "share") == 0) {
                        // share
                        const char* name = next_arg(argc, argv, argi);
                        const char* path = next_arg(argc, argv, argi);
                        no_more_args(argc, argi);
                        add_share(name, path);
                } else if (strcmp(arg, "user") == 0) {
                        // user
                        const char* name = next_arg(argc, argv, argi);
                        const char* password = next_arg(argc, argv, argi, true);
                        no_more_args(argc, argi);
                        add_user(name, password);
                } else
                        print_usage_and_exit(true);
        } else if (strcmp(arg, "remove") == 0) {
                // remove
                arg = next_arg(argc, argv, argi);
                if (strcmp(arg, "share") == 0) {
                        // share
                        const char* name = next_arg(argc, argv, argi);
                        no_more_args(argc, argi);
                        remove_share(name);
                } else if (strcmp(arg, "user") == 0) {
                        // user
                        const char* name = next_arg(argc, argv, argi);
                        no_more_args(argc, argi);
                        remove_user(name);
                } else
                        print_usage_and_exit(true);
        } else if (strcmp(arg, "permissions") == 0) {
                // permissions
                const char* user = next_arg(argc, argv, argi);
                const char* share = next_arg(argc, argv, argi);
                uint32 permissions = 0;
                while (argi < argc) {
                        uint32 perms = 0;
                        arg = next_arg(argc, argv, argi);
                        if (!get_permissions(arg, &perms))
                                print_usage_and_exit(true);
                        permissions |= perms;
                }
                set_user_permissions(user, share, permissions);
        } else {
                print_usage_and_exit(true);
        }

        return 0;
}