//#include <iostream>
#include <jni.h>
#include <memory.h>
#include "MatrixOpCommon.h"

bool Matrix::identicalDataSpaces(Matrix & other)
{
    if (address != other.address)				
        return JNI_FALSE;
    if (stride  != other.stride)				
        return JNI_FALSE;
    if ((width * height) != (other.width * other.height)) 	 
        return JNI_FALSE;
    return JNI_TRUE;
}

bool Matrix::intersectingDataSpaces(Matrix & other)
{
    char * my_max_address    = &address[ stride * elements ];
    char * other_max_address = &other.address[ other.stride * other.elements];
    
    if (address >= other.address || address <= other_max_address)	return JNI_TRUE;
    if (other.address >= address || other.address <= my_max_address) return JNI_TRUE;
    return JNI_FALSE;
}

void Matrix::transposeMatrix(float * src, float * dst, int src_width, int src_height)
{
    // square matrix transpose
    if (src_width == src_height)
    {
        for (int i = 0; i < src_width; i++)
                for (int j = 0; j < src_width; j++)
                        dst[i + src_width * j] = src[j + i * src_width];
    }
    // non square matrix transpose
    else
    {
        for (int i = 0; i < src_width; i ++)
                for (int j = 0; j < src_height; j++)
                        dst[i + src_height * j] = src[j + i * src_height];
    }	
}

void Matrix::transposeMatrix(float * mat, int src_width, int src_height)
{
    float temp;

    // square matrix transpose
    if (src_width == src_height)
    {
            for (int col = 0; col < src_width; col++)
            {
                    for (int row = col+1; row < src_height; row++)
                    {
                            // swap the two elements
                            temp = mat [col * src_height + row];
                            mat[col * src_height + row] = mat[row * src_width + col];
                            mat[row * src_width + col] = temp;
                    }
            }
    }
    // non square matrix transpose
    else
    {
            transposeMatrix(mat, transpose_record, src_width, src_height);
            memcpy(mat, transpose_record, src_width * src_height * sizeof(float));
    }

}


MatrixSrc::MatrixSrc ( jint addr, jint s,
            jint w,    jint h, 
            jint e,	jboolean t):	
            Matrix(addr, s, e), 
            record_offset((char *) addr),
            record_size  (w*h)
{
    if (t) {	
        width = h;
        height = w;
    }
    else {
        width = w;
        height = h;
    }
    
    elements = e;
    record = new float[width * height];
    
    // vectors do not need to be transposed 
    transpose = (t == JNI_TRUE) && (w != 1) && (h != 1);
    
    if (transpose && (width != height))
        // only need temp storage for transpose if the matrix is not square
        transpose_record = new float[width*height];
    else
        transpose_record = 0;

    if (elements == 1)
    {
        // fool the nextMatrix function into returning a value
        elements = 2;
        nextMatrix();
        elements = 1;
    }
}

MatrixSrc::~MatrixSrc()
{
    //cout << "MatrixSrc destructor \n";
    
    delete [] record;
    
    if (transpose_record != 0)
       delete [] transpose_record;
}

float * MatrixSrc::nextMatrix()
{
    if (elements > 1)
    {
        //cout << "Elements: " << elements << "\n";
        //cout << "Address:  " << (unsigned int) (record_offset) << "\n";
        
        // the record is not properly aligned
        if ((unsigned int) (record_offset) & FLOAT_ALIGNMENT)
        {
            // copy the floats into a buffer so that they are aligned
            // on 4 byte margins (not necessary on intel, but a good thing)
            
            memcpy (record, record_offset, record_size * sizeof(float));

            if (transpose)
                transposeMatrix (record, height, width);

            record_offset = &record_offset[stride];
            current_record_ptr = record;
        }
        // the record is aligned but it has to be transposed
        else if (transpose)
        {
            transposeMatrix ((float *) (record_offset), record, height, width);
            record_offset = &record_offset[stride];
            current_record_ptr = record;
        }
        // nothing has to be done to the record
        else
        {
            // the floats are aligned in memory
            current_record_ptr = (float *) record_offset;
            record_offset = &record_offset[stride];
        }
    }

    return current_record_ptr;
}

MatrixDst::MatrixDst (jint addr, jint s, jint w, jint h, jint e, jboolean t): 
            Matrix(addr, s, e)	
{
    width = w;
    height = h;
    record_size = width * height;
    record = new float[record_size];

    // vectors do not need to be transposed 
    transpose = (t) && (w != 1) && (h != 1);
    
    if (transpose)
        transpose_record = new float[width*height];
    else
        transpose_record = 0;
        
    data_buffered   = JNI_FALSE;
    record_buffered = JNI_FALSE;
        
    record_offset = address - stride;
}

MatrixDst::~MatrixDst()
{
    //cout << "MatrixDst destructor \n";

    delete [] record;
    if (transpose_record != 0)
        delete [] transpose_record;

    // copy back any buffered data
    if (data_buffered)
    {
        char * src  = buffer;
        char * dest = address;
        
        for (int i = 0; i < elements; i++)
        {
            memcpy(dest, src, record_size * sizeof(float));
            src  += stride;
            dest += stride;
        }
        
        delete [] buffer;
    }
}

void MatrixDst::configureBuffer(MatrixSrc & a, MatrixSrc & b)
{


    if (!a.intersectingDataSpaces(b))
    {
        // as long as the output only overlays 1 of the sources, and the other
        // source only has 1 matrix in it, only a record_buffer is required
        if (a.elements == 1 && identicalDataSpaces(b))
            record_buffered = JNI_TRUE;
        else if (b.elements == 1 && identicalDataSpaces(a))
            record_buffered = JNI_TRUE;
        else 
        // otherwise all of the output has to be buffered
            createBuffer();
    }
    else
        createBuffer();
}

void MatrixDst::configureBuffer(MatrixSrc & a)
{
        if (identicalDataSpaces(a))
            record_buffered = JNI_TRUE;
        else if (intersectingDataSpaces(a))
            createBuffer();
}
            
void MatrixDst::createBuffer()
{
        data_buffered = JNI_TRUE;
        buffer = new char[ elements * stride ];
        record_offset = buffer - stride;
}

float * MatrixDst::nextMatrix()
{
    record_offset = &record_offset[stride];
    int alignment = ((unsigned int)(record_offset)) & FLOAT_ALIGNMENT;
    
    if (transpose || record_buffered || alignment)
    {
        last_record_in_temp = JNI_TRUE;
        return record;
    }
    else
    {
        last_record_in_temp = JNI_FALSE;
        return (float *) record_offset;
    }
}


void MatrixDst::writeComplete()
{	
    if (last_record_in_temp)
    {	
        // 3 reasons why the record would be in temp
        //
        //	1. The record is not aligned
        //	2. The result will need to be transposed
        //	3. Direct Mode where result would overlay an operand
        
        if (((unsigned int)(record_offset)) & FLOAT_ALIGNMENT)
        {
            if (transpose)
                transposeMatrix(record, width, height);
            memcpy (record, record_offset,  record_size * sizeof(jfloat));
        }
        else if (transpose)
        {
            transposeMatrix(record, (float *) &record_offset[0],  width, height);
        }
        else
            memcpy (record_offset, record, record_size * sizeof(jfloat));
    }
}

///////////////////////////////////////////////////////////////////////////

void subMatrix (const float * src, int side, float * dst , int col_omit, int row_omit)
{
    int index = 0;
    int src_index = 0;

    for (int c = 0; c < side; c++)
    {
        if (c == col_omit)
        {   src_index += side;
            continue;
        }
        for (int r = 0; r < side; r++)
        {
            if (r == row_omit)
            {	src_index++;
                continue;
            }
            dst[index++] = src[src_index++];
        }
    }
} 

float determinant (const float * matrix , int side)
{


    // we are assuming for this case that the data is in column major format
    
    float det = 0;

    if (side == 2)
        // your basic cross product aka 2x2 determinant
        det = matrix[0] * matrix[3] - matrix[2] * matrix[1];	
    else
    {
        // create room to store the sub matrix
        int   temp_side  = side - 1;				// the dimensions of the sub matrix
        float * temp_matrix = new float[temp_side * temp_side];

        // keep the sign (this way we avoid an additional branch in the inner loop)
        float	sign = 1;
        
        for (int row = 0; row < side; row++)
        {
            // get a sub matrix by eliminating the 0th col and the specified row
            subMatrix(matrix, side, temp_matrix, 0, row);
            
            // add to the determinant sign * [a]i0 * [M]i0
            det += sign * matrix[row] * determinant (temp_matrix, temp_side);
            
            // alternate the sign
            sign *= -1;
        }
        
        delete [] temp_matrix;
    }
    
    return det;
}