#ifndef __PCSVM_VECTOR__
#define __PCSVM_VECTOR__

#include <list>
#include <iostream>
#include <cmath>
#include <cassert>

#include "FullPolicy.hpp"
#include "SparsePolicy.hpp"

struct ZipItem
{
    int index;
    float value1;
    float value2;
};

namespace local {

    // klassen welchen nur intern benutzt werden
    //

    template<class VS>
    class ZipIter
    // wird nicht spezilaisert fuer FullPolicy.
    // tauch nämlich nur in dot() und tpao() auf, und
    // die werden fuer  FullPolicy eh spezialisiert.
    {
        public:
            ZipIter(const typename VS::item_iterator &b1,
                    const typename VS::item_iterator &e1,
                    const typename VS::item_iterator &b2,
                    const typename VS::item_iterator &e2):
                    it1_(b1), e1_(e1), it2_(b2), e2_(e2) { updateActual(); }

            ZipIter(const VS &p1, const VS &p2):
                   it1_(p1.begin()), e1_(p1.end()), it2_(p2.begin()), e2_(p2.end()) 
            { 
                if (VS::do_comp_test) 
                    assert(p1.len() == p2.len());
                updateActual(); 
            }

            void updateActual();
            bool isValid() { return it1_ != e1_ || it2_ != e2_; }

            const ZipItem* operator->() const { return &actual_; }
            const ZipItem  operator*()  const { return actual_; }

            ZipIter<VS > operator++()
            {
                    if (it1_ != e1_ && (it2_ == e2_ || it1_->index < it2_->index))
                            ++it1_;
                    else if (it2_ != e2_ && (it1_ == e1_ || it1_->index > it2_->index))
                            ++it2_;
                    else if (it1_ != e1_ && it2_ != e2_) {
                            ++it1_;
                            ++it2_;
                    }
                    updateActual();
                    return *this;
            }

        private:
            typename VS::const_item_iterator it1_, e1_, it2_, e2_;
            ZipItem  actual_;

    };

    template<class VS>
    void ZipIter<VS>::updateActual()
    {
        if (it1_ == e1_ && it2_ == e2_) return;

            if (it2_ == e2_) 
            {
                actual_.index  = it1_->index;
                actual_.value1 = it1_->value;
                actual_.value2 = 0;
                    return;
            } 
            if (it1_ == e1_)  
            {
                actual_.index  = it2_->index;
                actual_.value2 = it2_->value;
                actual_.value1 = 0;
                    return;
            } 
        // now: it1_ and it2_ are valid
            if (it1_->index < it2_->index) 
            {
                actual_.index  = it1_->index;
                actual_.value1 = it1_->value;
                actual_.value2 = 0;
                    return;
            } 

        // now: it1_ is valid
        if (it2_->index < it1_->index)
            {
                actual_.index  = it2_->index;
                actual_.value2 = it2_->value;
                actual_.value1 = 0;
                    return;
            } 
            if (it1_->index == it2_->index)
            {
                actual_.index  = it2_->index;
                actual_.value2 = it2_->value;
                actual_.value1 = it1_->value;
                    return;
            }
    }
} // namespace local



//////////////////////////////////////////////////////////////////////////////////
//
// HIER GEHTS LOS !!
//
//////////////////////////////////////////////////////////////////////////////////

template<class StoragePolicy>
class VectorBase: public StoragePolicy
{

    public:
        VectorBase(): StoragePolicy() {};
        VectorBase(int n): StoragePolicy(n) {};

        VectorBase(const StoragePolicy &p): StoragePolicy(p) {};

        typedef ::local::ZipIter<StoragePolicy> zip_iter;
        // this + alpha * other
        VectorBase<StoragePolicy> tpao(float a, const VectorBase<StoragePolicy> &other) const
        {
            if (StoragePolicy::do_comp_test) assert(this->len() == other.len());
            VectorBase<StoragePolicy> x(other.len());
            zip_iter it(*this,other);
            for (; it.isValid(); ++it)
                x[it->index]= (it->value1)+a*(it->value2);
            return x;
        }

		VectorBase<StoragePolicy> operator+(const VectorBase<StoragePolicy> &other) const
        {
            return tpao(1.0, other);
        }
		VectorBase<StoragePolicy> operator-(const VectorBase<StoragePolicy> &other) const
        {
            return tpao(-1.0, other);
        }
        
        template <class SPolicy>
        friend VectorBase<SPolicy> operator*(float alpha, const VectorBase<SPolicy> &other);

        template <class pol>
        friend float dot(const VectorBase<pol> &v1, const VectorBase<pol> &v2);

        float operator*(const VectorBase<StoragePolicy> &other) const { return dot(*this, other); }

		VectorBase<StoragePolicy> operator-() const
        {
            return operator*(-1.0f, *this);
        }

        float pNorm(float p) const
        {
            float sum = 0.0f;
            for (typename StoragePolicy::const_value_iterator  it = this->begin(); it != this->end(); ++it)
                sum += std::pow(*it, p);
            return std::pow(sum, 1.0f/p);
        }

        template<class pol>
        friend float euk_distance(const VectorBase<pol> &v1, const VectorBase<pol> &v2);


};

  
template<class SPolicy>
VectorBase<SPolicy> operator*(float alpha, const VectorBase<SPolicy> &other) 
{
    VectorBase<SPolicy> res(other.len());
    for (typename VectorBase<SPolicy>::const_item_iterator it=other.begin(); it != other.end(); ++it)
        res[it->index] = alpha*(it->value);
    return res;
}

	

template <class pol>
float dot(const VectorBase<pol> &v1, const VectorBase<pol> &v2)
{
    float sum =0.0f;
    typename VectorBase<pol>::zip_iter it(v1, v2);
    for (; it.isValid(); ++it)
        sum += it->value1*it->value2;
    return sum;

}

template<class pol>
float euk_distance(const VectorBase<pol> &v1, const VectorBase<pol> &v2)
{
    VectorBase<pol> diff = v1.tpao(-1.0, v2); // = v1-v2;
    float distsq = diff*diff;
    return std::sqrt(distsq);
}

template<class SP>
std::ostream & operator<<(std::ostream &os, const VectorBase<SP> &v)
{
    int l = v.len();
    typename VectorBase<SP>::const_value_iterator it=v.begin(); 
    int n = 0;
    if (it != v.end())
    {
        os << *it ;
        ++it;
        n = 1;
    }
    while (n<10 && it != v.end())
    {
        os << ", " ;
        os << *it ;
        ++it;
        ++n;
    }
    if (n==10 && it != v.end())
        os << ", ... ";
    return os;
}

        

    


////////////////////////////////////////////////////////////////////////////////
//
// spezialisierung zur optimierung der ausführungszeit
//
////////////////////////////////////////////////////////////////////////////////
//
float dot(const VectorBase<FullPolicy > &v1, const VectorBase<FullPolicy > &v2) 
{
    float sum=0.0f;
	// optimiert fuer Policy !
	int i;
    int n=v1.len();
    assert( n == v2.len());
    
	for (i=0; i+3<n; ++i)
	{
        sum += v1[i]*v2[i] ;
		++i;
		sum += v1[i]*v2[i] ;
		++i;
		sum += v1[i]*v2[i] ;
		++i;
		sum += v1[i]*v2[i] ;
	}
	for (; i<n; ++i)
		sum += v1[i]*v2[i];

    return sum;
}


VectorBase<FullPolicy > VectorBase<FullPolicy >::tpao(float a, const VectorBase<FullPolicy> &other) const
{
    assert(n_ == other.n_);

    VectorBase<FullPolicy> x(n_);
    int i;
	for (i=0; i<n_-3; ++i)
	{
        x[i]= this->operator[](i)+a*other[i];
		++i;
        x[i]= this->operator[](i)+a*other[i];
		++i;
        x[i]= this->operator[](i)+a*other[i];
		++i;
        x[i]= this->operator[](i)+a*other[i];
	}
	for (; i<n_; ++i)
        x[i]= this->operator[](i)+a*other[i];
    return x;
}


class Vector: public VectorBase<FullPolicy > {

    public:
        Vector(int n): VectorBase<FullPolicy>(n) { };
        Vector(const VectorBase<FullPolicy > &other): VectorBase<FullPolicy >(other) {};
};

class SparseVector: public VectorBase<SparsePolicy > {

    public:
        SparseVector(): VectorBase<SparsePolicy>() {};
        SparseVector(const VectorBase<SparsePolicy> &other): VectorBase<SparsePolicy>(other) {};
};

#endif