// netsvm.h

#pragma once

#include <limits>

#include "../SparseVector.hpp"
#include "../KernelFunction.hpp"
#include "../Problem.hpp"
#include "../Classifier.hpp"

#include <windows.h>
#include "_vcclrit.h"

using namespace System;
using namespace System::Collections;
using namespace System::Runtime::InteropServices;


namespace netsvm
{
    public __gc class Lib {
    public:
		 
	    static BOOL minitialize() {
		    BOOL retval = TRUE;
		    try {
            retval =  __crt_dll_initialize();
		    } catch(System::Exception* e) {
			    Console::WriteLine(e->Message);
			    retval = FALSE;
		    }
		    return retval;
	    }
	    static BOOL mterminate() {
		    BOOL retval = TRUE;
		    try {
                retval = __crt_dll_terminate();
		    } catch(System::Exception* e) {
						    Console::WriteLine(e->Message);
			    retval = FALSE;
		    }
		    return retval;
	    }
    };
	

	
    public __gc class SparseVector
	{
    public:
        pcsvm::SparseVector*    impl_;

	protected:
		~SparseVector();

    public:

        SparseVector();
		SparseVector(pcsvm::SparseVector *v);		
		
        float get(int i);
		void put(int i, float v);
		void push_back(float v);
				
	    static netsvm::SparseVector* op_Addition(netsvm::SparseVector *a, netsvm::SparseVector *b)
		{
			pcsvm::SparseVector * temp = new pcsvm::SparseVector;
			*temp = *(a->impl_) + *(b->impl_);
			
			SparseVector * rv = __gc new netsvm::SparseVector(temp);
			return rv;
		}

		static float op_Multiply(netsvm::SparseVector *a, netsvm::SparseVector *b)
		{
			return dot(*(a->impl_),*(b->impl_));
		}

		static netsvm::SparseVector* op_Multiply(float a, netsvm::SparseVector *b)
		{
			pcsvm::SparseVector * temp = new pcsvm::SparseVector;
			*temp = a * *(b->impl_);
			
			SparseVector * rv = new netsvm::SparseVector(temp);
			return rv;
		}
		static netsvm::SparseVector* op_Multiply(netsvm::SparseVector *a, float b)
		{
			return op_Multiply(b,a);
		}

		
		static netsvm::SparseVector* op_Subtraction(SparseVector *a, SparseVector *b)
		{
			pcsvm::SparseVector * temp = new pcsvm::SparseVector;
			*temp = *(a->impl_) - *(b->impl_);
			
			// temp wird nicht destructed, da rv die verwaltung der lebenszeit
			// übernimmt...
			SparseVector * rv = new netsvm::SparseVector(temp);
			return rv;
		}
		
		static double op_Division(SparseVector *a, SparseVector *b)
		{
			return *(a->impl_) / *(b->impl_);
		}

		static netsvm::SparseVector* op_UnaryNegation(SparseVector *a)
		{
			pcsvm::SparseVector * temp = new pcsvm::SparseVector;
			*temp = -*(a->impl_);
			
			SparseVector * rv = new netsvm::SparseVector(temp);
			return rv;
		}

		static netsvm::SparseVector* op_Assign(SparseVector *a, SparseVector *b)
		{
			if (a != b) // aliasing vermeiden
			{
			    if (a->impl_) delete a->impl_;
			    a->impl_ = b->impl_;
			}
			return a;
		}

		static double pDist(SparseVector * a, SparseVector * b, double p)
		{
			return pcsvm::pDist(*(a->impl_),*(b->impl_), p);
		}
		
		static double dist(SparseVector * a, SparseVector * b)
		{
			return pcsvm::dist(*(a->impl_),*(b->impl_));
		}

		String * to_str();
		void     prune(float eps);
		int      lastIndex();
		int      entries();
		void     clear();
		bool     empty();

		std::vector<float> * toVector(int index1, int index2);
		std::vector<float> * toVector(int index1) { return toVector(index1,-1); }
		std::vector<float> * toVector() { return toVector(0,-1); }
	    
	};
	

    public __gc class KernelBase
    {
	
    public:
		pcsvm::KernelBase * impl_;

	protected:
		KernelBase() {};
		virtual ~KernelBase() { delete impl_ ; };
    
    public:

		virtual float eval(SparseVector *v1, SparseVector *v2) { 
			return impl_->operator ()(*(v1->impl_),*(v2->impl_)); 
		}; 
        virtual bool isLinear() { return impl_->isLinear(); }
    };
		

	public __gc class LinearKernel: public KernelBase
	{
	public:
		LinearKernel() { impl_ = new pcsvm::LinearKernel(); }
	};

	public __gc class PolynomialKernel: public KernelBase
	{
	public:
		PolynomialKernel(float c, int d) { impl_ = new pcsvm::PolynomialKernel(c,d); }
		PolynomialKernel() { impl_ = new pcsvm::PolynomialKernel(1.0,2); }
		PolynomialKernel(int d) { impl_ = new pcsvm::PolynomialKernel(1.0,d); }
	};

	public __gc class RadialKernel: public KernelBase
	{
	public:
		RadialKernel(float c, float p) { impl_ = new pcsvm::RadialKernel(c,p); }
		RadialKernel(float c) { impl_ = new pcsvm::RadialKernel(c,2.0); }
	};


	public __gc class ClassificationExample
	{
	public:
		ClassificationExample() { };
		ClassificationExample(SparseVector *vec, bool lb): vector(vec), label(lb) {};
		SparseVector* vector;
		bool          label;
	};

		
	public __gc class ClassificationProblem
	{
		public:
			pcsvm::ClassificationProblem *impl_;
			ClassificationProblem() { impl_ = new pcsvm::ClassificationProblem(); }

		protected:
			~ClassificationProblem() { delete impl_; }

		public:  
			int size()       { return impl_->size(); }
			void clear()     { impl_->clear();}
			bool empty()     { return impl_->empty(); }
			void normalize() { return impl_->normalize(); }

			ClassificationExample*  at(int i);
			void push_back(SparseVector *sv, bool label);
			void push_back(ClassificationExample *ex);
	};

	public __gc class CSVMTrainInfo
	{
	public:
		unsigned int numIter, numSV;
		SparseVector * svWeights;
	};
		  
	public __gc class ClassifierCSVM
	{
	private:
		pcsvm::ClassifierCSVM * impl_;
	public:
		ClassifierCSVM(ClassificationProblem *p, KernelBase *k);
	protected:
		~ClassifierCSVM() { delete impl_; };

	public:	
		void setKernel(KernelBase *k) {
			impl_->setKernel(k->impl_);
		};

		CSVMTrainInfo* train(float cp, float cn);
		CSVMTrainInfo* train(float c) { return train(c,c); };

		CSVMTrainInfo* train() { 
			return train(FLT_MAX,FLT_MAX); 
		}

		float classify(SparseVector *s);

	};


}; // namepspace