/*
 * MathPlanner 3.1.1 - Mathematical design tool.
 * Copyright(C) 2002  Jarmo Nikkanen
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation.
 *
 * You should have received a copy of the GNU General Public License with this program.
 *
 */


#include "Unit.h"
#include "Error.h"
#include "ConfigReader.h"
#include <string.h>
#include <qregexp.h>
#include <stdlib.h>
#include <stdlib.h>


QString mpl_unit::UnitName(int i)
{
return(unit[i].unit+", "+unit[i].name);
}


QString mpl_unit::Subs(int i)
{
return(unit[i].subs);
}


QString mpl_unit::Display(QString n,bool f)
{
int i;
char pw[COUNT];
CreatePower(n,pw);
n=CreateSubs(pw);

if (f) for(i=0;i<total;i++) if (n==unit[i].subs) return(unit[i].unit);

n=CreateUnit(pw);
return(n);
}



QString mpl_unit::CreateUnit(char *pw)
{
int i;
bool f=false;
bool g=false;
QRegExp req("(\\w+)");
QString n,s,d;
s=" ";
d="/";
for(i=0;i<base;i++) if (pw[i]>0) {
      g=true;
      n=unit[i].unit;
      req.search(n);
      s+=req.cap(1);
      if (pw[i]==2) s+="²";
      else if (pw[i]==3) s+="³";
      else if (pw[i]>1) s+=QString::number((int)pw[i]);
}

for(i=0;i<base;i++) if (pw[i]<0) {
      f=true;
      n=unit[i].unit;
      req.search(n);
      d+=req.cap(1);
      if (pw[i]==-2) d+="²";
      else if (pw[i]==-3) d+="³";
      else if (pw[i]<-1)d+=QString::number(abs((int)pw[i]));
}
if (!g && f) s=" 1";
if (f) s+=d;


return(s);
}



QString mpl_unit::CreateSubs(char *pw)
{
int i;

QRegExp req("(\\w+)");
QString n,s,a,b;
s="";

for(i=0;i<base;i++) if (pw[i]!=0) {

    n=unit[i].unit;

    if (pw[i]!=1) {
      if (n.at(0)=='[') a="[",b="]";
      if (n.at(0)=='(') a="(",b=")";
      req.search(n);
      s+=a;
      s+=req.cap(1);
      if (pw[i]>0) s+="+";
      s+=QString::number((int)pw[i]);
      s+=b;
    }
    else s+=n;
}

return(s);
}






int mpl_unit::Units()
{
return(total);
}



QString mpl_unit::Unit(QString n)
{
QRegExp req("((\\(|\\[)\\w+)");
QRegExp req2("((\\)|\\]))");
req.search(n);
req2.search(n);
return(req.cap(1)+req2.cap(1));
}


int mpl_unit::FindUnit(QString n)
{
int i;
n=Unit(n);
for(i=0;i<total;i++) if (n==unit[i].unit) return(i);
return(-1);
}


bool mpl_unit::IsBaseUnit(QString n)
{
int i;
n=Unit(n);
for(i=0;i<total;i++) if (n==unit[i].unit) return(unit[i].base);
return(true);
}


QString mpl_unit::Argument(QString s,int n)
{
QString arg;
int l=s.length();
int pos=-1,i,c=0;
for(i=0;i<l;i++) if (s.at(i)=='(' || s.at(i)=='[') {
    c++;
    if (c==n) { pos=i; break; }
}

arg=QString("");

if (pos!=-1) {
  while(pos<l && s.at(pos)!=')' && s.at(pos)!=']') arg.append(s.at(pos++));
  arg.append(s.at(pos));
}

return(arg);
}


char mpl_unit::Power(QString arg)
{
  int po;
  QRegExp req("((?:\\+|\\-)\\d)");
  if (req.search(arg)!=-1) po=req.cap(1).toInt();
  else po=1;
  return(po);
}


void mpl_unit::CreatePowers()
{
int i;
for(i=0;i<total;i++) {
   if (unit[i].base==false) {
     CreatePower(unit[i].subs,unit[i].pwrs);
     unit[i].subs=CreateSubs(unit[i].pwrs);
   }
 } // for
}

void mpl_unit::Add(char *pw)
{
       int x;
       for(x=0;x<base;x++) pwrs[x]+=pw[x];
}

void mpl_unit::Sub(char *pw)
{
       int x;
       for(x=0;x<base;x++) pwrs[x]-=pw[x];
}


void mpl_unit::Compare(char *pw)
{
       int x;
       for(x=0;x<base;x++) if (pwrs[x]!=pw[x]) { Clear(); break; }
}


void mpl_unit::Clear()
{
       int x;
       for(x=0;x<COUNT;x++) pwrs[x]=0;
}

void mpl_unit::CreatePower(QString str,char *pw)
{
       int x,un,no;
       bool go;
       QString arg;

       for(x=0;x<COUNT;x++) pw[x]=0;

       go=true;
       no=0;

       while(go) {

            no++;
            arg=Argument(str,no);

            if (arg.isEmpty()) go=false;
            else {

                 un=FindUnit(arg);
                 if (un==-1) ErrorReport("Config File:","Unit declaration error... Missing Base-unit");
                 else pw[un]+=Power(arg);

            }
       } // while
}




void mpl_unit::ProcessSubs()
{
    int i=0,un=0,no=0;
    bool go;
    QString arg,sub;

    for(i=0;i<total;i++) {
      if (unit[i].base==false) {

         sub=unit[i].subs;
         unit[i].subs=QString("");
         go=true;
         no=0;

         while(go) {

            no++;
            arg=Argument(sub,no);

            if (arg.isEmpty()) go=false;
            else {
               if (IsBaseUnit(arg)) unit[i].subs.append(arg);
               else {
                 un=FindUnit(arg);
                 if (un==-1) ErrorReport("Config File:","Unit declaration error");
                 else unit[i].subs.append(unit[un].subs);
               }
            }
          } // while
      }
   } // for
}





mpl_unit::mpl_unit(config_file_reader *Prefs)
{
    bool go=true;
    int no=0,i=0;
    char *lat;
    char *co,*tok;
    char se[]=" ,;";
    char name[16];

    base = total = 0;

    while(go) {
      sprintf(name,"Base%d",i+1);
      if (Prefs->Has(name)) {
        co=strdup(Prefs->String(name).latin1());
        if (co) {
            tok=strtok(co,se);
            if (tok) unit[no].unit=QString(tok);
            tok=strtok(NULL,se);
            if (tok) unit[no].name=QString(tok);
            unit[no].base=true;
            base++;
            total++;
            free(co);
            no++;
            i++;
        }
        else ErrorReport("Unit","Error");
      }
      else go=false;
    }



    i=0;
    go=true;
    while(go) {
      sprintf(name,"Prefix%d",i+1);
      if (Prefs->Has(name)) {
        lat=(char *)Prefs->String(name).latin1();
        co=strdup(lat);
        if (co) {
            tok=strtok(co,se);
            if (tok) unit[no].unit=QString(tok);
            tok=strtok(NULL,se);
            if (tok) unit[no].name=QString(tok);
            tok=strtok(NULL,se);
            if (tok) unit[no].prefix=(char)QString(tok).toInt();
            unit[no].base=true;
            base++;
            total++;
            free(co);
            no++;
            i++;
        }
      }
      else go=false;
    }




    i=0;
    go=true;
    while(go) {
      sprintf(name,"Unit%d",i+1);
      if (Prefs->Has(name)) {
        lat=(char *)Prefs->String(name).latin1();
        co=strdup(lat);
        if (co) {
            tok=strtok(co,se);
            if (tok) unit[no].unit=QString(tok);
            tok=strtok(NULL,se);
            if (tok) unit[no].name=QString(tok);
            tok=strtok(NULL,se);
            if (tok) unit[no].subs=QString(tok);
            unit[no].base=false;
            total++;
            free(co);
            no++;
            i++;
        }
      }
      else go=false;
    }

    if (base>=COUNT) ErrorReport("Unit:","Too many base-units");

    ProcessSubs();
    CreatePowers();


}