/*
 * caesar-atbasch.cpp
 *
 * Copyright 2014 Leon Giesenkämper <leon@darksider3.de>
 *
 * 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; either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 * MA 02110-1301, USA.
 *
 *
 */

/* CAE_ATB.h */
#ifndef CAE_ATB_H
#define CAE_ATB_H
#include <iostream>
#include <cstdio>
#include "darkstring.cpp"
class caesar
{
  private:
    char *decodedString;
    int length;
    bool encoded;
    darkstring *io;
  public:
    char *encodedString;
    char *encode(const int move);
    char *decode(const int move);
    darkstring dencode(const int move);
    darkstring ddecode(const int move);

    caesar(char const *str)
    {
      io=new darkstring(str);
      //encodedString=nullptr;
      encoded=false;
      int i=0;
      length=mystrlen(str);
      decodedString=new char[length];
      encodedString=new char[length];
      while(str[i])
      {
        decodedString[i]=str[i];
        i++;
      }
    }
    void copy_decode()
    {
      int i=0;
      if(!encoded)
        copy_encode();
        while(i < length)
      {
        decodedString[i]=encodedString[i];
        i++;
      }
    }
    void copy_encode()
    {
      int i=0;
      encoded=true;
      while(i < length)
      {
        encodedString[i]=decodedString[i];
        i++;
      }
    }
    ~caesar()
    {
      delete[](decodedString);
      delete[](encodedString);
    }
};
//######################ENCODING#######################################
char *caesar::encode(const int move)
{
  copy_encode();
  int i=0;
  while(i < length)
  {
    //Buchstabe?!
    if(move==0)
      return encodedString;
    if(isalpha(encodedString[i]))
    {
      int r=move%26;
      if(encodedString[i] >= 'A' && encodedString[i] <= 'Z')
      {
        if(encodedString[i]+r > 'Z')
        {
          encodedString[i]=encodedString[i]-26;
        }
        encodedString[i]=encodedString[i]+r;
      }
      else if(encodedString[i] >= 'a' && encodedString[i] <= 'z')
      {
        if(encodedString[i]+r > 'z')
        {
          encodedString[i]=encodedString[i]-26;
        }
        encodedString[i]=encodedString[i]+r;
      }
    }
    i++;
  }
  return encodedString;
}
darkstring caesar::dencode(const int move)
{
  copy_encode();
  int i=0;
  while(i < length)
  {
    //Buchstabe?!
    if(move==0)
      return encodedString;
    if(isalpha(encodedString[i]))
    {
      int r=move%26;
      if(encodedString[i] >= 'A' && encodedString[i] <= 'Z')
      {
        if(encodedString[i]+r > 'Z')
        {
          encodedString[i]=encodedString[i]-26;
        }
        encodedString[i]=encodedString[i]+r;
      }
      else if(encodedString[i] >= 'a' && encodedString[i] <= 'z')
      {
        if(encodedString[i]+r > 'z')
        {
          encodedString[i]=encodedString[i]-26;
        }
        encodedString[i]=encodedString[i]+r;
      }
    }
    i++;
  }
  return darkstring(encodedString);
}
//###################################DECODING###########################
char *caesar::decode(const int move)
{
  copy_decode();
  int i=0;
  while(i < length)
  {
    if(isalpha(decodedString[i]))
    {
      int r=move%26;
      if(decodedString[i] >= 'A' && decodedString[i] <= 'Z')
      {
        if(decodedString[i]-r < 'A')
        {
          decodedString[i]=decodedString[i]+26;
        }
        decodedString[i]=decodedString[i]-r;
      }
      else if(decodedString[i] >= 'a' && decodedString[i] <= 'z')
      {
        if(decodedString[i]-r < 'a')
        {
          decodedString[i]=decodedString[i]+26;
        }
        decodedString[i]=decodedString[i]-r;
      }
    }
    i++;
  }
  return decodedString;
}

darkstring caesar::ddecode(const int move)
{
  copy_decode();
  int i=0;
  while(i < length)
  {
    if(isalpha(decodedString[i]))
    {
      int r=move%26;
      if(decodedString[i] >= 'A' && decodedString[i] <= 'Z')
      {
        if(decodedString[i]-r < 'A')
        {
          decodedString[i]=decodedString[i]+26;
        }
        decodedString[i]=decodedString[i]-r;
      }
      else if(decodedString[i] >= 'a' && decodedString[i] <= 'z')
      {
        if(decodedString[i]-r < 'a')
        {
          decodedString[i]=decodedString[i]+26;
        }
        decodedString[i]=decodedString[i]-r;
      }
    }
    i++;
  }
  return darkstring(decodedString);
}
/*####################################################################*/
 class atbash
{
  private:
    char *startString;
    char *encodedString;
    int length;
  public:
    atbash(char const *sString)
    {
      int i=0;
      length=mystrlen(sString);
      startString=new char[length];
      encodedString=new char[length];
      while(i < length)
      {
        startString[i]=sString[i];
        i++;
      }
    }
    char *encode()
    {
      int i=0;
      int upperCache='A'+'Z';
      int lowerCache='a'+'z';
      while(i < length)
      {
        if(isalpha(startString[i]))
        {
          if(startString[i] >= 'A' && startString[i] <= 'Z')
          {
            encodedString[i]=upperCache-startString[i];
          }
          if(startString[i] >= 'a' && startString[i] <= 'z')
          {
            encodedString[i]=lowerCache-startString[i];
          }
        }
        else
        {//if the char isnt a letter, copy it without change
          encodedString[i]=startString[i];
        }
        i++;
      }
      return encodedString;
    }
    char *decode()
    {
      return encode();
    }

    ~atbash()
    {
      delete(encodedString);
      delete(startString);
    }
};
#endif /* CAE_ATB.h */
bool Test_CAE(int trys, const bool debug=true, const bool full=true)
{
  int i=0, size=20;
  char Testchars[20]="Hallo Leon";
  int results[trys];
  while(i < trys)
  {
    caesar Test1(Testchars);
    /* Debugging true?*/
    if(debug)
    {
      Test1.encode(i);
      int y=0;
      char *debugres=Test1.decode(i);
      while(y < size)
      {
        if(debugres[y]==Testchars[y])
        {
          results[y]=true;
        }
        else
        {
          results[y]=false;
        }

        y++;
      }
      y=0;
      while(y < size)
      {
        if(results[y])
          return true;
        else
          return false;
      }
    }
    else
    {
      /*Debugging false*/
      std::cout << "#############Count: "<< i << "########################" << std::endl;
      std::cout << "Encoded: " <<Test1.encode(i)<<std::endl;
      std::cout <<  std::endl <<Test1.decode(i) <<std::endl;
    }
    if(full)
    {
      caesar text("Ibmmp Mfpo");
      char *debugres=text.decode(1);
      if(debugres=="Hallo Leon")
      {
        return true;
      }
    }
    i++;
  }
  return true;
}


int main(int argc, char **argv)
{
  /*if(Test_CAE(26, true,true)==true)
    std::cout << "Successfully!\n";*/
  caesar bbl("haha");
  //std::cout << Test.encode() << std::endl;
  std::cout <<bbl.dencode(5);
  std::cout <<bbl.ddecode(5);
}