/*
 * Copyright (c) 2003-2005, Haiku
 *
 * This software is part of the Haiku distribution and is covered
 * by the MIT license.
 *
 * Authors:
 *              Scott Dellinger (dellinsd@myrealbox.com)
 *              Axel Dörfler, axeld@pinc-software.de.
 */

/**     Description: Adds an index to a volume. */


#include <fs_info.h>
#include <fs_index.h>
#include <TypeConstants.h>
#include <Directory.h>
#include <Path.h>
#include <Volume.h>

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


static struct option const kLongOptions[] = {
        {"volume", required_argument, 0, 'd'},
        {"type", required_argument, 0, 't'},
        {"copy-from", required_argument, 0, 'f'},
        {"verbose", no_argument, 0, 'v'},
        {"help", no_argument, 0, 'h'},
        {NULL}
};

extern const char *__progname;
static const char *kProgramName = __progname;


static void
copy_indexes(dev_t from, dev_t to, bool verbose)
{
        DIR *indexes = fs_open_index_dir(from);
        
        if (verbose)
                puts("Copying indexes:");

        while (dirent *dirent = fs_read_index_dir(indexes)) {
                if (!strcmp(dirent->d_name, "name")
                        || !strcmp(dirent->d_name, "size")
                        || !strcmp(dirent->d_name, "last_modified"))
                        continue;

                index_info info;
                if (fs_stat_index(from, dirent->d_name, &info) != 0) {
                        fprintf(stderr, "%s: Skipped index \"%s\": %s\n",
                                kProgramName, dirent->d_name, strerror(errno));
                        continue;
                }

                if (fs_create_index(to, dirent->d_name, info.type, 0) != 0) {
                        if (errno == B_BAD_VALUE || errno == B_FILE_EXISTS) {
                                // B_BAD_VALUE is what BeOS returns here...
                                continue;
                        }
                        fprintf(stderr, "%s: Could not create index \"%s\": %s\n",
                                kProgramName, dirent->d_name, strerror(errno));
                } else if (verbose)
                        printf("\t%s\n", dirent->d_name);
        }

        fs_close_index_dir(indexes);
}


static void
usage(int status)
{
        fprintf(stderr,
                "Usage: %s [options] <attribute>\n"
                "Creates a new index for the specified attribute.\n"
                "\n"
                "  -d, --volume=PATH\ta path on the volume to which the index will be added,\n"
                "\t\t\tdefaults to current volume.\n"
                "  -t, --type=TYPE      the type of the attribute being indexed.  One of \"int\",\n"
                "\t\t\t\"llong\", \"string\", \"float\", or \"double\".\n"
                "\t\t\tDefaults to \"string\".\n"
                "      --copy-from\tpath to volume to copy the indexes from.\n"
                "  -v, --verbose\t\tprint information about the index being created\n",
                kProgramName);

        exit(status);
}


int
main(int argc, char **argv)
{
        const char *indexTypeName = "string";
        int indexType = B_STRING_TYPE;
        char *indexName = NULL;
        bool verbose = false;
        dev_t device = -1, copyFromDevice = -1;

        int c;
        while ((c = getopt_long(argc, argv, "d:ht:v", kLongOptions, NULL)) != -1) {
                switch (c) {
                        case 0:
                                break;
                        case 'd':
                                device = dev_for_path(optarg);
                                if (device < 0) {
                                        fprintf(stderr, "%s: can't get information about volume: %s\n",
                                                kProgramName, optarg);
                                        return -1;
                                }
                                break;
                        case 'f':
                                copyFromDevice = dev_for_path(optarg);
                                if (copyFromDevice < 0) {
                                        fprintf(stderr, "%s: can't get information about volume: %s\n",
                                                kProgramName, optarg);
                                        return -1;
                                }
                                break;
                        case 'h':
                                usage(0);
                                break;
                        case 't':
                                indexTypeName = optarg;
                                if (strncmp("int", optarg, 3) == 0)
                                        indexType = B_INT32_TYPE;
                                else if (strncmp("llong", optarg, 5) == 0)
                                        indexType = B_INT64_TYPE;
                                else if (strncmp("string", optarg, 6) == 0)
                                        indexType = B_STRING_TYPE;
                                else if (strncmp("float", optarg, 5) == 0)
                                        indexType = B_FLOAT_TYPE;
                                else if (strncmp("double", optarg, 6) == 0)
                                        indexType = B_DOUBLE_TYPE;
                                else
                                        usage(1);
                                break;
                        case 'v':
                                verbose = 1;
                                break;
                        default:
                                usage(1);
                                break;
                }
        }

        if (device == -1) {
                // Create the index on the volume of the current
                // directory if no volume was specified.

                device = dev_for_path(".");
                if (device < 0) {
                        fprintf(stderr, "%s: can't get information about current volume\n", kProgramName);
                        return -1;
                }
        }

        if (copyFromDevice != -1) {
                copy_indexes(copyFromDevice, device, verbose);
                return 0;
        }

        if (argc - optind == 1) {
                // last argument
                indexName = argv[optind];
        } else
                usage(1);

        if (verbose) {
                /* Get the mount point of the specified volume. */
                BVolume volume(device);
                BDirectory dir;
                volume.GetRootDirectory(&dir);
                BPath path(&dir, NULL);

                printf("Creating index \"%s\" of type %s on volume mounted at %s.\n",
                        indexName, indexTypeName, path.Path());
        }

        if (fs_create_index(device, indexName, indexType, 0) != 0)
                fprintf(stderr, "%s: Could not create index: %s\n", kProgramName, strerror(errno));

        return 0;
}