#include <iostream>

#include "BlockChain.h"
#include "Utilities.h"

enum COMMANDS
{
    FORMAT, HASH, COMPRESS, VERIFY, ERROR
};

int compareString(const char *s1, const char *s2)
{
    while (*s1 && (*s1 == *s2))
    {
        s1++;
        s2++;
    }
    return *s1 - *s2;
}

COMMANDS getCommand(char *op)
{
    if (!compareString(op, "format"))
        return FORMAT;
    if (!compareString(op, "hash"))
        return HASH;
    if (!compareString(op, "compress"))
        return COMPRESS;
    if (!compareString(op, "verify"))
        return VERIFY;
    return ERROR;
}

void format(char *readPath, char *hashPath)
{
    ifstream read(readPath);
    ofstream write(hashPath);
    BlockChain chain = BlockChainLoad(read);
    BlockChainDump(chain, write);
    BlockChainDestroy(chain);
}

void hash(char *readPath, char *hashPath)
{
    ifstream read(readPath);
    ofstream write(hashPath);
    BlockChain chain = BlockChainLoad(read);
    BlockChainDumpHashed(chain, write);
    BlockChainDestroy(chain);
}

void compress(char *readPath, char *hashPath)
{
    ifstream read(readPath);
    ofstream write(hashPath);
    BlockChain chain = BlockChainLoad(read);
    BlockChainCompress(chain);
    BlockChainDump(chain, write);
    BlockChainDestroy(chain);
}

void verify(char *readPath, char *hashPath)
{
    ifstream read(readPath), hash(hashPath);
    BlockChain chain = BlockChainLoad(read);
    if (BlockChainVerifyFile(chain, hash))
        std::cout << "Verification passed" << std::endl;
    else
        std::cout << "Verification failed" << std::endl;
    BlockChainDestroy(chain);
}

int main(int argc, char **argv)
{
    if (argc == 4)
    {
        COMMANDS op = getCommand(argv[1]);
        switch (op)
        {
            case FORMAT:
            {
                format(argv[2], argv[3]);
                break;
            }
            case HASH:
            {
                hash(argv[2], argv[3]);
                break;
            }
            case COMPRESS:
            {
                compress(argv[2], argv[3]);
                break;
            }
            case VERIFY:
            {
                verify(argv[2], argv[3]);
                break;
            }
            default:
                std::cout << getErrorMessage() << std::endl;
        }
    }
    else
        std::cout << getErrorMessage() << std::endl;

    return 0;
}