#include <hashtab.hh>

Hashtab::Hashtab(const int n, char* filnamn)
{
  char ch;
  filnamn_=filnamn;
  cout<<"\nProcessing file "<<filnamn<<"\n";
  btree_=new BinTree();
  clean();
  handle_=build(n);       //skapar en länkad lista av temporära stränglager
  SimpleList* tmp=handle_;
  ifstream f1(filnamn); 
  if (!f1) cerr<<"Cannot open "<<filnamn<<" for reading!\n";
  int j=1;
  while (f1.get(ch))
  {
    for (int i=0; i<n; i++)
    {
      if (j>i)           //"fasar in" avläsningen i början av filen
      {
	if (tmp->hangon(ch)==n)
	{
	  hashin(tmp->hashnumber());
	  tmp->clean();
	}
      }
      tmp=tmp->nxt();
    }
    j++;  
  }
  f1.close();
  cout<<"Total length "<<totant()<<'\n';
}

Hashtab::Hashtab(Hashtab* btree)
{ 
  filnamn_=btree->filn();
  handle_=0;  //struntar i att ansluta ngt temporärt lager här
  btree_->copy(btree->btree_); //ger en kopia av hela trädet
  /*
     for (int i=0;i<hashlangd;i++) //parsa hela trädet
     btree_->sortin(i);
  */
  totant_=btree->totant();
}

Hashtab::Hashtab()  //centroidhashtabellskonstruktör
{
  btree_=new BinTree();
  filnamn_="centroid";
  handle_=0;  //inget temporärt stränglager behövs här
  totant_=0;
}


Hashtab::~Hashtab()
{
  if (handle_!=0)
  {
    SimpleList* tmp=handle_;
    while (tmp->nxt()!=handle_)
      tmp=tmp->nxt();
    tmp->next(0);
    delete handle_;
    delete btree_;
  }
}

void Hashtab::clean()
{
  delete btree_;
  btree_=new BinTree();
  totant_=0;
}

int Hashtab::totant()
{
  return totant_;
}

char* Hashtab::filn()
{
  char* tmp=filnamn_;
  char* hld=filnamn_;
  while (*tmp!='\0')
  {
    if (*tmp=='/') hld=tmp+1;
    tmp++;
  }
  return hld;
}

BinTree* Hashtab::btree()
{
  return btree_;
}

double Hashtab::ant(longint nr)
{
  return btree_->get(nr);
}

void Hashtab::hashin(longint hashnr)
{
  btree_->sortin(hashnr);
  totant_++;
}

void Hashtab::set(longint nr, double varde)
{
  btree_->set(nr,varde);
}

SimpleList* Hashtab::build(const int n)
{
  SimpleList* first=new SimpleList("",0);
  SimpleList* thisone=first;
  for (int i=1; i<n; i++)
  {
    SimpleList* newone=new SimpleList("",0);
    thisone->next(newone);
    thisone=newone;
  }
  thisone->next(first);
  return first;
}

double Hashtab::dist()
{
  BinTree* tmp=btree_->min();
  double lgd=0;
  while (tmp!=0)
  {
    lgd+=tmp->ant()*tmp->ant();
    tmp=tmp->next(tmp->nGnr());
  }
  lgd=sqrt(lgd);
  return lgd;
}

double Hashtab::comp(Hashtab* a)
{
  char tch;
  double sum=0;
  BinTree* tmp=btree_->min();
  BinTree* btmp=a->btree_->min();
  while ((tmp->next(tmp->nGnr())!=0) && (btmp->next(btmp->nGnr())!=0))
  {
    longint this_nGnr=tmp->nGnr();
    longint b_nGnr=btmp->nGnr();
    if (tmp->nGnr()==btmp->nGnr())
    {
      sum+=tmp->ant()*btmp->ant();
      tmp=tmp->next(this_nGnr);
      btmp=btmp->next(b_nGnr);
    }
    else
    {
      if (tmp->nGnr()<btmp->nGnr())
      {
	tmp=tmp->next(this_nGnr);
      }
      else
      {
	btmp=btmp->next(b_nGnr);
      }
    }
    if (tmp==0)
    {
      cout<<"Oj, nu är ju tmp nollpekaren!\n";
      cin>>tch;
    }
    if (btmp==0) 
    {
      cout<<"Oj, nu är ju btmp nollpekaren!\n";
      cin>>tch;
    }
  }  //när något av träden är (nästan) slut
  longint this_nGnr=tmp->nGnr();
  longint b_nGnr=btmp->nGnr();
  if ((tmp->next(this_nGnr)!=0) || (btmp->next(b_nGnr)!=0)) //om båda träden är
  {                                                         //slut, hoppa över
    if (tmp->next(this_nGnr)==0)         //här funkar det nog inte som det ska
    {
      while ((btmp->next(b_nGnr)!=0) && (btmp->nGnr()<b_nGnr))
      {     
	if (tmp->nGnr()==btmp->nGnr())
	  sum+=tmp->ant()*btmp->ant();
	b_nGnr=btmp->nGnr();
	btmp=btmp->next(b_nGnr);
	b_nGnr=btmp->nGnr();
      }
    }
    else
    {
      while (tmp->next(this_nGnr)!=0)
      {     
	if (tmp->nGnr()==btmp->nGnr())
	  sum+=tmp->ant()*btmp->ant();
	this_nGnr=tmp->nGnr();
	tmp=tmp->next(this_nGnr);
	this_nGnr=tmp->nGnr();
      }
    } //när båda träden är (nästan) slut
  }
  b_nGnr=btmp->nGnr();
  this_nGnr=tmp->nGnr();
  if (tmp->nGnr()==btmp->nGnr())
    sum+=tmp->ant()*btmp->ant();
  sum/=a->dist()*this->dist();
  return sum;
}

double Hashtab::comp(Hashtab* a, Hashtab* centroid)
{
  char tch;
  double sum=0;
  Hashtab* tmptree= new Hashtab(this);
  tmptree-centroid;
  Hashtab* btmptree= new Hashtab(a);
  btmptree-centroid;
  BinTree* tmp=tmptree->btree()->min();
  BinTree* btmp=btmptree->btree()->min();
  while ((tmp->next(tmp->nGnr())!=0) && (btmp->next(btmp->nGnr())!=0))
  {
    longint this_nGnr=tmp->nGnr();
    longint b_nGnr=btmp->nGnr();
    if (tmp->nGnr()==btmp->nGnr())
    {
      sum+=tmp->ant()*btmp->ant();
      tmp=tmp->next(this_nGnr);
      btmp=btmp->next(b_nGnr);
    }
    else
    {
      if (tmp->nGnr()<btmp->nGnr())
      {
	tmp=tmp->next(this_nGnr);
      }
      else
      {
	btmp=btmp->next(b_nGnr);
      }
    }
    if (tmp==0)
    {
      cout<<"Oj, nu är ju tmp nollpekaren!\n";
      cin>>tch;
    }
    if (btmp==0) 
    {
      cout<<"Oj, nu är ju btmp nollpekaren!\n";
      cin>>tch;
    }
  }  //när något av träden är (nästan) slut
  longint this_nGnr=tmp->nGnr();
  longint b_nGnr=btmp->nGnr();
  if ((tmp->next(this_nGnr)!=0) || (btmp->next(b_nGnr)!=0)) //om båda träden är
  {                                                         //slut, hoppa över
    if (tmp->next(this_nGnr)==0)         //här funkar det nog inte som det ska
    {
      while ((btmp->next(b_nGnr)!=0) && (btmp->nGnr()<b_nGnr))
      {     
	if (tmp->nGnr()==btmp->nGnr())
	  sum+=tmp->ant()*btmp->ant();
	b_nGnr=btmp->nGnr();
	btmp=btmp->next(b_nGnr);
	b_nGnr=btmp->nGnr();
      }
    }
    else
    {
      while (tmp->next(this_nGnr)!=0)
      {     
	if (tmp->nGnr()==btmp->nGnr())
	  sum+=tmp->ant()*btmp->ant();
	this_nGnr=tmp->nGnr();
	tmp=tmp->next(this_nGnr);
	this_nGnr=tmp->nGnr();
      }
    } //när båda träden är (nästan) slut
  }
  b_nGnr=btmp->nGnr();
  this_nGnr=tmp->nGnr();
  if (tmp->nGnr()==btmp->nGnr())
    sum+=tmp->ant()*btmp->ant();
  sum/=a->dist()*this->dist();
  delete tmptree;
  delete btmptree;
  return sum;
}

void Hashtab::operator-(Hashtab* a)
{
  BinTree* tmp=btree_->min();
  BinTree* btmp=a->btree_->min();
  while ((tmp->next(tmp->nGnr())!=0) && (btmp->next(btmp->nGnr())!=0))
  {
    if (tmp->nGnr()==btmp->nGnr())
    {
      tmp->setant(tmp->ant()-btmp->ant());
      tmp=tmp->next(tmp->nGnr());
      btmp=btmp->next(btmp->nGnr());
    }
    if (tmp->nGnr()<btmp->nGnr())
      tmp=tmp->next(tmp->nGnr());
    if (tmp->nGnr()>btmp->nGnr())
      btmp=btmp->next(btmp->nGnr());
  }  //när något av träden är (nästan) slut
  if (tmp->next(tmp->nGnr())==0)
    while (btmp->next(btmp->nGnr())!=0)
      {     
      if (tmp->nGnr()==btmp->nGnr())
	tmp->setant(tmp->ant()-btmp->ant());
      btmp=btmp->next(btmp->nGnr());
    }
  if (btmp->next(btmp->nGnr())==0)
    while (tmp->next(tmp->nGnr())!=0)
    {     
      if (tmp->nGnr()==btmp->nGnr())
	tmp->setant(tmp->ant()-btmp->ant());
      tmp=tmp->next(tmp->nGnr());
    } //när båda träden är (nästan) slut
  if (tmp->nGnr()==btmp->nGnr())
    tmp->setant(tmp->ant()-btmp->ant());
}