//
//  Copyright (c) 2013 Joaquim Duran
//
//  Distributed under the Boost Software License, Version 1.0. (See
//  accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//

#include <boost/numeric/ublas/assignment.hpp>
#include <boost/numeric/ublas/matrix_sparse.hpp>
#include <boost/numeric/ublas/matrix.hpp>
#include <boost/numeric/ublas/matrix_vector.hpp>
#include "common/testhelper.hpp"
#include "utils.hpp"

using namespace boost::numeric::ublas;


template <class Vector, class StorageCategory>
void guardSparsePreserveResize( Vector &vec, typename Vector::size_type new_size, StorageCategory) // Because sparse matrices don't have preserve data implemented
{
    vec.resize( new_size );
}


template <class Vector>
void guardSparsePreserveResize( Vector &vec, typename Vector::size_type new_size, sparse_tag) // Because sparse matrices don't have preserve data implemented
{
    vec.resize( new_size, false );
}

template <class Matrix>
bool test_matrix_row_facade() {
    bool pass = true;

    typedef matrix_row_vector<Matrix> RowVector;

    { // Testing resize
    BOOST_UBLAS_DEBUG_TRACE( "test_matrix_row_facade: resize" );

    typename Matrix::size_type num_rows = 3;
    typename Matrix::size_type num_cols = 5;
		
    Matrix matrix(num_rows, num_cols);
    RowVector rows(matrix);
    pass &= (matrix.size1() == num_rows);
    pass &= (rows.size() == num_rows);
    pass &= (matrix.size2() == num_cols);
	
    typename Matrix::size_type new_num_rows = 6;
    guardSparsePreserveResize( rows, new_num_rows, typename Matrix::storage_category());
    //rows.resize(new_num_rows);

    pass &= (matrix.size1() == new_num_rows);
    pass &= (rows.size() == new_num_rows);
    pass &= (matrix.size2() == num_cols);
    }

    { // Testing operator()
    BOOST_UBLAS_DEBUG_TRACE( "test_matrix_row_facade: operator()" );

    Matrix A(3,3), RA(3,3);
    RowVector rows(A);

    RA <<=  1, 2, 3,
            4, 5, 6,
            7, 8, 9;

    for(typename Matrix::size_type i = 0; i < A.size1(); i++) {
        rows(i) = matrix_row<Matrix>(RA, i);
    }
    
    pass &= compare_distance(A, RA);
    }

    { // Testing operator[]
    BOOST_UBLAS_DEBUG_TRACE( "test_matrix_row_facade: operator[]" );

    Matrix A(3,3), RA(3,3);
    RowVector rows(A);

    RA <<=  1, 2, 3,
            4, 5, 6,
            7, 8, 9;
		
    for(typename Matrix::size_type i = 0; i < A.size1(); i++) {
        rows[i] = matrix_row<Matrix>(RA, i);
    }
    
    pass &= compare_distance(A, RA);
    }
    
    { // Testing operator[] const
    BOOST_UBLAS_DEBUG_TRACE( "test_matrix_row_facade: operator[] const" );

    Matrix RA(3,3);
    RowVector rows(RA);

    RA <<=  1, 2, 3,
            4, 5, 6,
            7, 8, 9;

    for(typename Matrix::size_type i = 0; i < RA.size1(); i++) {
      pass &= compare_distance(rows[i], matrix_row<Matrix>(RA, i));
    }
    }

    { // Testing const iterator
    BOOST_UBLAS_DEBUG_TRACE( "test_matrix_row_facade: const iterator" );

    Matrix RA(3,3);
    RowVector rows(RA);

    RA <<=  1, 2, 3,
            4, 5, 6,
            7, 8, 9;

    typename RowVector::size_type i = 0;
    for(typename RowVector::const_iterator iter = rows.begin();
	iter != rows.end();
	iter++) {
      pass &= compare_distance(*iter, matrix_row<Matrix>(RA, i++));
    }
    }

    { // Testing iterator
    BOOST_UBLAS_DEBUG_TRACE( "test_matrix_row_facade: iterator" );

    Matrix A(3,3), RA(3,3);
    RowVector rows(A);

    RA <<=  1, 2, 3,
            4, 5, 6,
            7, 8, 9;

    typename RowVector::size_type i = 0;
    for(typename RowVector::iterator iter = rows.begin();
	iter != rows.end();
	iter++) {
      *iter = matrix_row<Matrix>(RA, i++);
    }

    pass &= compare_distance(A, RA);
    }

    { // Testing reserse iterator
    BOOST_UBLAS_DEBUG_TRACE( "test_matrix_row_facade: reverse iterator" );

    Matrix A(3,3), RA(3,3);
    RowVector rows(A);

    RA <<=  1, 2, 3,
            4, 5, 6,
            7, 8, 9;

    typename RowVector::size_type i = rows.size();
    for(typename RowVector::reverse_iterator iter = rows.rbegin();
	iter != rows.rend();
	iter++) {
      *iter = matrix_row<Matrix>(RA, --i);
    }

    pass &= compare_distance(A, RA);
    }

    { // Testing const reverse iterator
    BOOST_UBLAS_DEBUG_TRACE( "test_matrix_row_facade: const reverse iterator" );

    Matrix RA(3,3);
    RowVector rows(RA);

    RA <<=  1, 2, 3,
            4, 5, 6,
            7, 8, 9;

    typename RowVector::size_type i = rows.size();
    for(typename RowVector::const_reverse_iterator iter = rows.rbegin();
	iter != rows.rend();
	iter++) {
      pass &= compare_distance(*iter, matrix_row<Matrix>(RA, --i));
    }
    }

    return pass;
}


template <class Matrix>
bool test_matrix_column_facade() {
    bool pass = true;

    typedef matrix_column_vector<Matrix> ColumnVector;

    { // Testing resize
    BOOST_UBLAS_DEBUG_TRACE( "test_matrix_column_facade: resize" );
    typename Matrix::size_type num_rows = 5;
    typename Matrix::size_type num_cols = 3;
    
    Matrix matrix(num_rows, num_cols);
    ColumnVector columns(matrix);
    pass &= (matrix.size2() == num_cols);
    pass &= (columns.size() == num_cols);
    pass &= (matrix.size1() == num_rows);
	
    typename Matrix::size_type new_num_cols = 6;
    guardSparsePreserveResize( columns, new_num_cols, typename Matrix::storage_category());
    //columns.resize(new_num_cols);
    pass &= (matrix.size2() == new_num_cols);
    pass &= (columns.size() == new_num_cols);
    pass &= (matrix.size1() == num_rows);
    }

    { // Testing operator ()
    BOOST_UBLAS_DEBUG_TRACE( "test_matrix_column_facade: operator()" );

    Matrix A(3,3), RA(3,3);
    ColumnVector columns(A);

    RA <<=  1, 2, 3,
            4, 5, 6,
            7, 8, 9;
		
    for(typename Matrix::size_type i = 0; i < A.size2(); i++) {
        columns(i) = matrix_column<Matrix>(RA, i);
    }
    
    pass &= compare_distance(A, RA);
    }

    { // Testing operator[]
    BOOST_UBLAS_DEBUG_TRACE( "test_matrix_column_facade: operator[]" );

    Matrix A(3,3), RA(3,3);
    ColumnVector columns(A);

    RA <<=  1, 2, 3,
            4, 5, 6,
            7, 8, 9;
		
    for(typename Matrix::size_type i = 0; i < A.size2(); i++) {
        columns[i] = matrix_column<Matrix>(RA, i);
    }
    
    pass &= compare_distance(A, RA);
    }
    
    { // Testing operator[] const
    BOOST_UBLAS_DEBUG_TRACE( "test_matrix_column_facade: operator[] const" );

    Matrix RA(3,3);
    ColumnVector columns(RA);

    RA <<=  1, 2, 3,
            4, 5, 6,
            7, 8, 9;

    for(typename Matrix::size_type i = 0; i < RA.size2(); i++) {
      pass &= compare_distance(columns[i], matrix_column<Matrix>(RA, i));
    }
    }

    { // Testing iterator
    BOOST_UBLAS_DEBUG_TRACE( "test_matrix_column_facade: iterator" );

     Matrix A(3,3), RA(3,3);
    ColumnVector columns(A);

    RA <<=  1, 2, 3,
            4, 5, 6,
            7, 8, 9;

    typename ColumnVector::size_type i = 0;
    for(typename ColumnVector::iterator iter = columns.begin();
	iter != columns.end();
	iter++) {
      *iter = matrix_column<Matrix>(RA, i++);
    }

    pass &= compare_distance(A, RA);
    }

    { // Testing const iterator
    BOOST_UBLAS_DEBUG_TRACE( "test_matrix_column_facade: const iterator" );

    Matrix RA(3,3);
    ColumnVector columns(RA);

    RA <<=  1, 2, 3,
            4, 5, 6,
            7, 8, 9;

    typename ColumnVector::size_type i = 0;
    for(typename ColumnVector::const_iterator iter = columns.begin();
	iter != columns.end();
	iter++) {
      pass &= compare_distance(*iter, matrix_column<Matrix>(RA, i++));
    }
    }

    { // Testing reserse iterator
    BOOST_UBLAS_DEBUG_TRACE( "test_matrix_column_facade: reverese iterator" );

    Matrix A(3,3), RA(3,3);
    ColumnVector columns(A);

    RA <<=  1, 2, 3,
            4, 5, 6,
            7, 8, 9;

    typename ColumnVector::size_type i = columns.size();
    for(typename ColumnVector::reverse_iterator iter = columns.rbegin();
	iter != columns.rend();
	iter++) {
      *iter = matrix_column<Matrix>(RA, --i);
    }

    pass &= compare_distance(A, RA);
    }

    { // Testing const reverse iterator
    BOOST_UBLAS_DEBUG_TRACE( "test_matrix_column_facade: const reverese iterator" );

    Matrix RA(3,3);
    ColumnVector columns(RA);

    RA <<=  1, 2, 3,
            4, 5, 6,
            7, 8, 9;

    typename ColumnVector::size_type i = columns.size();
    for(typename ColumnVector::const_reverse_iterator iter = columns.rbegin();
	iter != columns.rend();
	iter++) {
      pass &= compare_distance(*iter, matrix_column<Matrix>(RA, --i));
    }
    }

    return pass;
}


BOOST_UBLAS_TEST_DEF (test_matrix_row_facade) {

    BOOST_UBLAS_DEBUG_TRACE( "Starting matrix row vector facade" );

    BOOST_UBLAS_DEBUG_TRACE( "Testing matrix..." );
    BOOST_UBLAS_TEST_CHECK(test_matrix_row_facade<matrix<double> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_row_facade<matrix<float> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_row_facade<matrix<long> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_row_facade<matrix<unsigned long> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_row_facade<matrix<int> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_row_facade<matrix<unsigned int> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_row_facade<matrix<std::size_t> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_row_facade<matrix<char> >());

    BOOST_UBLAS_DEBUG_TRACE( "Testing bounded_matrix..." );
    BOOST_UBLAS_TEST_CHECK((test_matrix_row_facade<bounded_matrix<double,7, 7> >()));
    BOOST_UBLAS_TEST_CHECK((test_matrix_row_facade<bounded_matrix<float,7, 7> >()));
    BOOST_UBLAS_TEST_CHECK((test_matrix_row_facade<bounded_matrix<long,7, 7> >()));
    BOOST_UBLAS_TEST_CHECK((test_matrix_row_facade<bounded_matrix<unsigned long,7, 7> >()));
    BOOST_UBLAS_TEST_CHECK((test_matrix_row_facade<bounded_matrix<int,7,7 > >()));
    BOOST_UBLAS_TEST_CHECK((test_matrix_row_facade<bounded_matrix<unsigned int,7, 7> >()));
    BOOST_UBLAS_TEST_CHECK((test_matrix_row_facade<bounded_matrix<char,7, 7> >()));
    BOOST_UBLAS_TEST_CHECK((test_matrix_row_facade<bounded_matrix<std::size_t,7, 7> >()));

    BOOST_UBLAS_DEBUG_TRACE( "Testing mapped_matrix..." );
    BOOST_UBLAS_TEST_CHECK(test_matrix_row_facade<mapped_matrix<double> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_row_facade<mapped_matrix<float> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_row_facade<mapped_matrix<long> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_row_facade<mapped_matrix<unsigned long> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_row_facade<mapped_matrix<int> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_row_facade<mapped_matrix<unsigned int> >())
    BOOST_UBLAS_TEST_CHECK(test_matrix_row_facade<mapped_matrix<std::size_t> >())
    BOOST_UBLAS_TEST_CHECK(test_matrix_row_facade<mapped_matrix<char> >());

    BOOST_UBLAS_DEBUG_TRACE( "Testing compressed_matrix..." );
    BOOST_UBLAS_TEST_CHECK(test_matrix_row_facade<compressed_matrix<double> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_row_facade<compressed_matrix<float> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_row_facade<compressed_matrix<long> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_row_facade<compressed_matrix<unsigned long> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_row_facade<compressed_matrix<int> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_row_facade<compressed_matrix<unsigned int> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_row_facade<compressed_matrix<std::size_t> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_row_facade<compressed_matrix<char> >());

    BOOST_UBLAS_DEBUG_TRACE( "Testing coordinate_matrix..." );
    BOOST_UBLAS_TEST_CHECK(test_matrix_row_facade<coordinate_matrix<double> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_row_facade<coordinate_matrix<float> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_row_facade<coordinate_matrix<long> >())
    BOOST_UBLAS_TEST_CHECK(test_matrix_row_facade<coordinate_matrix<unsigned long> >())
    BOOST_UBLAS_TEST_CHECK(test_matrix_row_facade<coordinate_matrix<int> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_row_facade<coordinate_matrix<unsigned int> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_row_facade<coordinate_matrix<std::size_t> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_row_facade<coordinate_matrix<char> >());
}


BOOST_UBLAS_TEST_DEF (test_matrix_column_facade) {

    BOOST_UBLAS_DEBUG_TRACE( "Starting matrix row column facade" );

    BOOST_UBLAS_TEST_CHECK(test_matrix_column_facade<matrix<double> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_column_facade<matrix<float> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_column_facade<matrix<long> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_column_facade<matrix<unsigned long> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_column_facade<matrix<int> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_column_facade<matrix<unsigned int> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_column_facade<matrix<std::size_t> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_column_facade<matrix<char> >());

    BOOST_UBLAS_TEST_CHECK((test_matrix_column_facade<bounded_matrix<double,7, 7> >()));
    BOOST_UBLAS_TEST_CHECK((test_matrix_column_facade<bounded_matrix<float,7, 7> >()));
    BOOST_UBLAS_TEST_CHECK((test_matrix_column_facade<bounded_matrix<long,7, 7> >()));
    BOOST_UBLAS_TEST_CHECK((test_matrix_column_facade<bounded_matrix<unsigned long,7, 7> >()));
    BOOST_UBLAS_TEST_CHECK((test_matrix_column_facade<bounded_matrix<int,7,7 > >()));
    BOOST_UBLAS_TEST_CHECK((test_matrix_column_facade<bounded_matrix<unsigned int,7, 7> >()));
    BOOST_UBLAS_TEST_CHECK((test_matrix_column_facade<bounded_matrix<char,7, 7> >()));
    BOOST_UBLAS_TEST_CHECK((test_matrix_column_facade<bounded_matrix<std::size_t,7, 7> >()));

    BOOST_UBLAS_TEST_CHECK(test_matrix_column_facade<mapped_matrix<double> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_column_facade<mapped_matrix<float> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_column_facade<mapped_matrix<long> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_column_facade<mapped_matrix<unsigned long> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_column_facade<mapped_matrix<int> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_column_facade<mapped_matrix<unsigned int> >())
    BOOST_UBLAS_TEST_CHECK(test_matrix_column_facade<mapped_matrix<std::size_t> >())
    BOOST_UBLAS_TEST_CHECK(test_matrix_column_facade<mapped_matrix<char> >());

    BOOST_UBLAS_TEST_CHECK(test_matrix_column_facade<compressed_matrix<double> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_column_facade<compressed_matrix<float> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_column_facade<compressed_matrix<long> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_column_facade<compressed_matrix<unsigned long> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_column_facade<compressed_matrix<int> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_column_facade<compressed_matrix<unsigned int> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_column_facade<compressed_matrix<std::size_t> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_column_facade<compressed_matrix<char> >());

    BOOST_UBLAS_TEST_CHECK(test_matrix_column_facade<coordinate_matrix<double> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_column_facade<coordinate_matrix<float> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_column_facade<coordinate_matrix<long> >())
    BOOST_UBLAS_TEST_CHECK(test_matrix_column_facade<coordinate_matrix<unsigned long> >())
    BOOST_UBLAS_TEST_CHECK(test_matrix_column_facade<coordinate_matrix<int> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_column_facade<coordinate_matrix<unsigned int> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_column_facade<coordinate_matrix<std::size_t> >());
    BOOST_UBLAS_TEST_CHECK(test_matrix_column_facade<coordinate_matrix<char> >());
}


int main () {
    BOOST_UBLAS_TEST_BEGIN();

    BOOST_UBLAS_TEST_DO( test_matrix_row_facade );
    BOOST_UBLAS_TEST_DO( test_matrix_column_facade );

    BOOST_UBLAS_TEST_END();
}