#include <math.h>
#include <windows.h>
#include <tlist.h>
#include <fstream.h>
#include <mappingf.h>;

//#include <arrmapf.h>;
//#include <mtarray.h>;







class Point
{
public:
double x,y,z;
Point() : x(0), y(0), z(0) {};
Point(double xx, double yy, double zz):
		x(xx), y(yy), z(zz) {};

double px() {return x;}
double py() {return y;}
double pz() {return z;}

friend
ostream&  operator << (ostream& stm,   const Point& p)
{
stm<<p.x<<","<<p.y<<","<<p.z;
}


};
//----------------------------------------------------------

class Voltage
{


public:
int status;
int hId;	//horizontal identifier
int vId;        //vertical identifier
double u;

SetStatus(int s) { status=s; }
int GetStatus() { return status; }
SetVoltage(double vu) { u=vu; }



Voltage() : hId(0), vId(0), u(0){};

friend
ostream& operator << ( ostream& stm, const Voltage& vlt )
{
stm<<"VOLTAGE," <<vlt.hId <<"," <<vlt.vId <<"," <<vlt.u<<","
<<vlt.status;


};

friend
istream&  operator >> (istream& istm,   Voltage& vlt){};

};

//----------------------------------------------------------



class Electrode : public Point, public Voltage
{
//int status;
public:
Electrode() :  Voltage(){};

//SetStatus(int s) { status=s; }

SetVal(double xx, double yy, double zz, double uu, int s)
{x=xx; y=yy; z=zz; u=uu; status=s;}



friend
ostream& operator << ( ostream& stm, const Electrode& elec );
friend
istream&  operator >> (istream& istm,   Electrode& elec);

};



ostream& operator << ( ostream& stm, const Electrode& elec )
{
stm<<"ELECTRODE," <<elec.hId <<"," <<elec.vId <<"," <<elec.u <<","
   <<elec.x <<"," <<elec.y <<"," <<elec.z <<","<<elec.status;
}


istream&  operator >> (istream& istm,  Electrode& elec)
{
char tmpc;
int i;
//eating initial string
//      E    L     E      C     T     R     O    D     E     ,
istm>>tmpc>>tmpc>>tmpc>>tmpc>>tmpc>>tmpc>>tmpc>>tmpc>>tmpc>>tmpc;

istm >>elec.hId>>tmpc >>elec.vId>>tmpc >>elec.u>>tmpc
     >>elec.x>>tmpc   >>elec.y>>tmpc   >>elec.z>>tmpc
     >>elec.status;
return istm;
}







//----------------------------------------------------------

class Charge : public Point
{
//protected:
public:
	int Id;
	double q;
	Charge() : Point(), Id(0), q(0){};
Charge(double xx, double yy, double zz, double qq):
	Point(xx,yy,zz), q(qq){}

	void SetId(int Num) { Id = Num; }

friend
ostream& operator << ( ostream& stm, const Charge& c )
{
stm<<"CHARGE"<<","<<c.x<<","<<c.y<<","<<c.z<<","<<c.q;
};


friend
istream&  operator >> (istream& istm,   Charge& c)
{};


};


///////////////////////////////////////////////////////////////////
class Mapping;


class Sequence
{

TLink<Charge> * _ActCharge;
int        _ActChargeid;
int _maxVid;
int _maxHid;

public:
TList<Voltage> voltages;
TList<Charge> charges;

SetActCharge(TLink<Charge> *  &c)	{ _ActCharge = c; }
SetActChargeN(int n)	{ SetActCharge( charges.Get(n) ); }

int maxVid(){ return _maxVid; }
int maxHid(){ return _maxHid; }



TLink<Charge> * ActCharge() 	{ return _ActCharge; }

AddCharge(Charge c)
{
 charges.Add(c);
 SetActCharge(charges.Get(1));
}


RemoveActCharge()
{
 charges.Remove(ActCharge() );
   SetActCharge(charges.Get(1));
// it will be beter set as active previous charge here
// not the first one
}


Charge * GetActCharge()
{
  if( _ActCharge != 0)
    {
        return (Charge *)(_ActCharge->Data() ) ;
    }
}


int GetActChargeId()
{
  if( _ActCharge != 0)
    {
        return _ActCharge->id() ;
    }
}




ModifyActCharge(double xx, double yy, double zz, double qq)
{
  if( _ActCharge != 0)
    {

     ( (Charge *)(_ActCharge->Data() ) )->x=xx;
     ( (Charge *)(_ActCharge->Data() ) )->y=yy;
     ( (Charge *)(_ActCharge->Data() ) )->z=zz;
     ( (Charge *)(_ActCharge->Data() ) )->q=qq;


    }
}





//find the neaerst charge from point (x,y,z)

TLink<Charge> * FindCharge(double x, double y, double z)
{


const Link* pLink = charges.GetHead(); //_pHead;

TLink<Charge>* tpLink=(TLink<Charge>*)pLink;
TLink<Charge>* tpLink1=(TLink<Charge>*)pLink;

Charge * p=(Charge *)(tpLink->Data());


double distance=(p->x-x)*(p->x-x)+(p->y-y)*(p->y-y)+(p->z-z)*(p->z-z);
double curdistance=distance;


while ( pLink != 0 )
 {
  tpLink = (TLink<Charge>*)pLink;
  p =(Charge*)(tpLink->Data());
  curdistance=(p->x-x)*(p->x-x)+(p->y-y)*(p->y-y)+(p->z-z)*(p->z-z);

if(curdistance<distance){tpLink1=tpLink; distance=curdistance;}

 pLink = pLink->Next();
 }

return tpLink1;
}


//------------
SetmaxHVId()
{


const Link* pLink = voltages.GetHead(); //_pHead;
TLink<Voltage>* tpLink = (TLink<Voltage>*)pLink;

Voltage * p=(Voltage *)(tpLink->Data());


int maxH = 0;
int maxV = 0;

int curH=maxH;
int curV=maxV;

while ( pLink != 0 )
 {
  tpLink = (TLink<Voltage>*)pLink;
  p =(Voltage*)(tpLink->Data());
  curH=(p->hId);
  curV=(p->vId);
if( maxH < curH ){ maxH=curH;}
if( maxV < curV ){ maxV=curV;}

 pLink = pLink->Next();
 }

_maxHid = maxH;
_maxVid = maxV;
}


//-----------------
Sequence() : _ActCharge(0), _ActChargeid(0) {}

Sequence(Sequence &seq) :
voltages(seq.voltages),
charges(seq.charges)
{};



friend
ostream& operator << ( ostream& stm, const Sequence& seq )
{
stm<<endl<<"Sequence";
stm<<endl<<"voltages";
stm<<seq.voltages;
stm<<endl<<"charges";
stm<<seq.charges;
};

friend
istream&  operator >> (istream& istm,   Sequence& seq)
{};




//------------------------------------------------------------------
//definition for potential of n electric charges PT( , , ) [V]
//------------------------------------------------------------------

double Potential(double x, double y, double z)
{
//GAMMA electricity constant
 double GAMMA = 8987551787.3681764;

   double PT = 0;
   const Link * pLink = charges.GetHead();
   TLink<Charge> * pTLink =  (TLink<Charge> *)pLink;
   const Charge * pc;

//ofstream fill("charge.tst");

	while ( pLink != 0 )
	{

	 pc = ( (TLink<Charge> *)pLink )->Data();

	 double delta = sqrt( pow( (x - ( pc->px()) ), 2)
		         +pow( (y - ( pc->py()) ), 2)
		         +pow( (z - ( pc->pz()) ), 2 ));

	 PT = PT + (GAMMA*(pc->q ) )/(delta);

//fill<<endl<<(pc->px())<<","
//          <<(pc->py())<<","
//          <<(pc->pz())<<","
//          <<(pc->q)<<","
//          <<"delta = "<<delta<<"//";

		pLink =  pLink -> Next() ;



	}
return PT;
}


Calculate(){}



};



//---------------------------------------
#define  MAPPING_EMPTY 		0
#define  MAPPING_ELECTRODES_LOADED 	1
#define  MAPPING_OK		2
class Mapping
{
int        _status;
TLink<Sequence> * _ActSeq;
int        _ActSeqid;
int _GND;
TList<Electrode> electrodes;
TList<Sequence> sequences;

public:

Calculate()
{
ofstream ffil("pot1.tst");
ffil<<endl<<"potential value test1";
MessageBeep(0);MessageBeep(0);MessageBeep(0);MessageBeep(0);

    const Link * pLink = electrodes.GetHead();
    const Link * pLink1 = GetActSequence() -> voltages.GetHead();

    TLink<Electrode> * pTLink  = (TLink<Electrode> *)pLink;
    TLink<Voltage>   * pTLink1 = (TLink<Voltage> *)pLink1;
    const Electrode * pe;
    const Voltage * pv;

    Sequence * pseq = GetActSequence();

    double potential;

    while( pLink != 0 )
      {

      pTLink  = (TLink<Electrode> *)pLink;
      pTLink1 = (TLink<Voltage> *)pLink1;

      pe = pTLink->Data();
      pv = pTLink1->Data();
      potential = pseq->Potential( pe->px(), pe->py(), pe->pz());

      //scale potential in [uV]
      potential = 1000000*potential - _GND;
      pv->SetVoltage( potential );


//ffil<<endl<<pe->px()<<","<<pe->py()<<","<<pe->pz()<<","<<potential;
ffil<<endl<<potential;

ffil<<endl<<*pv;


  pLink= pLink ->Next();
  pLink1= pLink1 ->Next();

      }

}


Beep()
{
MessageBeep(0);MessageBeep(0);MessageBeep(0);MessageBeep(0);
};





int Status()	  { return _status; }
SetStatus(int status) 	  {_status = status;}


//TLink<Electrode> * GetElectrodes()
  //    { return ( TLink<Electrode> * ) electrodes.GetHead(); }

TList<Electrode> * GetElectrodes()
      { return &electrodes; }

int AddSequence();
TLink<Sequence> * ActSeq() 	{ return _ActSeq; }
SetActSeq( TLink<Sequence> *  &s)	{ _ActSeq = s; }
SetActSeqN(int n)	{ SetActSeq( sequences.Get(n) ); }

RemoveActSequence()
{
 sequences.Remove(ActSeq() );
   SetActSeq(sequences.Get(1));
// it will be beter set as active previous sequence here
// not the first one (like in charges)
}

Sequence *GetActSequence()
{
  if( _ActSeq != 0)
    {
        return (Sequence *)(_ActSeq->Data() ) ;
    }
}





//CHARGES FUNCTION
AddCharge(Charge c)
{
if(_ActSeq != 0)
{
 (_ActSeq->Data())->AddCharge(c);

//cout<<endl<<"adding charge to act seq";
}


}

RemoveActCharge()
{
if(_ActSeq != 0)
{
 (_ActSeq->Data())->RemoveActCharge();}
}

ModifyActCharge(double xx, double yy, double zz, double qq)
{
if(_ActSeq != 0)
  {
     (_ActSeq->Data())->ModifyActCharge( xx, yy, zz, qq);
  }
}


Charge * GetActCharge()
{
if(_ActSeq != 0)
  {
     (_ActSeq->Data())->GetActCharge();
  }
}




Mapping(): _status(MAPPING_EMPTY),
           _ActSeq(0),
           _ActSeqid(0),
           _GND(0) {};


friend
ostream& operator << ( ostream& stm, const Mapping& mpg );


friend
LoadElectrodes(Mapping& map, char * path);
};




ostream& operator << ( ostream& stm, const Mapping& mpg )
{
stm<<endl<<"MAPPING";
stm<<mpg.electrodes;
//stm<<endl<<"number of electrodes "<<mpg.electrodes.LinkNum();
stm<<mpg.sequences;
};



LoadElectrodes(Mapping& map, char * path)
{
FB<Electrode> fbrowser(&map.electrodes, path);
fbrowser.ReadObjects();
map.SetStatus(MAPPING_ELECTRODES_LOADED);
}


//****************************************
Mapping::AddSequence()
{
if(_status == MAPPING_EMPTY) {return -1; } //errorr


if(_status == MAPPING_ELECTRODES_LOADED)
{

TList<Voltage> tmpVltList;

TList_iterator<Electrode> ESrcTiter(electrodes);
const TLink<Electrode> * EsrcTLink;
while( EsrcTLink=ESrcTiter++ )
{
tmpVltList.Add( *(EsrcTLink->Data()) );
}


Sequence s;
TList_iterator<Voltage> SrcTiter(tmpVltList);
const TLink<Voltage> * srcTLink;
while( srcTLink=SrcTiter++ )
{
s.voltages.Add( *(srcTLink->Data()) );
}

sequences.Add(s);
SetStatus(MAPPING_OK);
SetActSeq(sequences.Get(1));
GetActSequence()->SetmaxHVId();
return 1;
}


if(_status == MAPPING_OK)
{
//cout<<endl<<"adding actual seq";
sequences.Add(*(ActSeq()->Data()) );
SetActSeq(sequences.Get(1));
GetActSequence()->SetmaxHVId();
return 1;
}

}