/*
 * Josh Holtrop
 * 2008-10-01
 * Grand Valley State University
 * CS677
 * Programming Assignment #2
 */

#include <iostream>
#include <fstream>
#include <vector>
#include <pthread.h>
using namespace std;

#define eq(x, y) ( ( (x) == (y) ) || ( (x) == '?' ) || ( (y) == '?' ) )

typedef struct
{
    vector<char> * s;
    vector<char> * t;
    int id;
} SMArg;

void usage(char * prog);
void * similarityMatrix(void * arg);
bool readFile(char * fileName, vector<char> & v);

/* Print basic usage information */
void usage(char * prog)
{
    cout << "Usage: " << prog << " [-n <num_threads>] <file1> <file2>" << endl;
    exit(42);
}

int main(int argc, char * argv[])
{
    vector<char> files[2];
    int num_threads = 1;
    int file_to_read = 0;

    for (int i = 1; i < argc; i++)
    {
        if ( ! strcmp("-n", argv[i]) )
        {
            if (i == argc - 1)
                usage(argv[0]);
            i++;
            num_threads = atoi(argv[i]);
        }
        else
        {
            if (file_to_read < 2)
                readFile(argv[i], files[file_to_read]);
            else
                usage(argv[0]);
            file_to_read++;
        }
    }

    if (file_to_read != 2)
        usage(argv[0]);

    pthread_t * threads = new pthread_t[num_threads];

    for (int i = 0; i < num_threads; i++)
    {
        SMArg * arg = new SMArg;
        arg->s = &files[0];
        arg->t = &files[1];
        arg->id = i;

        int ret = pthread_create(&threads[i], NULL, &similarityMatrix, arg);
        if (ret)
        {
            cerr << "Error " << ret << " when creating thread!" << endl;
            return -4;
        }
    }

    for (int i = 0; i < num_threads; i++)
    {
        pthread_join(threads[i], NULL);
    }

    delete[] threads;
    return 0;
}

/* Read a file into a vector of non-space characters */
bool readFile(char * fileName, vector<char> & v)
{
    ifstream in(fileName);
    if (!in.is_open())
        return false;
    while (!in.eof())
    {
        char chr;
        in >> chr;
        v.push_back(chr);
    }
    return true;
}

/* Compute the similarity matrix between two character arrays */
void * similarityMatrix(void * arg)
{
    SMArg * smarg = (SMArg *) arg;
    int s_size = smarg->s->size();
    int t_size = smarg->t->size();
    int F[s_size][t_size];
    int max_x = 0, max_y = 0, max_val = 0;
    for (int i = 0; i < t_size; i++)    /* set first row to 0's */
        F[0][i] = 0;
    for (int i = 0; i < s_size; i++)    /* set first column to 0's */
        F[i][0] = 0;
    for (int i = 1; i < s_size; i++)
    {
        for (int j = 1; j < t_size; j++)
        {
            /* Compute the value for the matrix */
            F[i][j] =
                max(
                    max(
                        F[i][j-1] - 2,
                        F[i-1][j-1] +
                            (eq(smarg->s->at(i),  smarg->t->at(j)) ? 1 : -1)
                    ),
                    max(
                        F[i-1][j] - 2,
                        0
                    )
                );
            /* See if we found a new maximum value */
            if (F[i][j] > max_val)
            {
                max_val = F[i][j];
                max_x = i;
                max_y = j;
            }
            else if (F[i][j] == max_val)
            {
                /* If we found a value the same as our current maximum
                 * value, see if it has a greater i+j value */
                if ( (i + j) > (max_x + max_y) )
                {
                    max_x = i;
                    max_y = j;
                }
            }
        }
    }

    cout << "Maximum value is " << max_val << " at position ("
        << max_x << ", " << max_y << ")" << endl;

    delete smarg;
    return NULL;
}