#include <iostream>
#include <cstdio>
#include <utility>
#include <vector>
#include <cassert>

//List of Return Value Codes:
//2 => O/P File Error.
//3 => I/P File Error.
//4 => Too Few Arguments.

//List of Vector Error Strinds:
//1 => Unexpected End of File Encountered.

typedef int (*Action)(FILE*&);
std::vector<Action> fsm_vec;
std::vector<std::string> _evec;
FILE* _dest;

class RAII_File {
  FILE*& _pfile;
  RAII_File (RAII_File const&);
  RAII_File& operator= (RAII_File const&);
public:
  RAII_File (FILE*& _pf) : _pfile(_pf) { }
  ~RAII_File () { fclose (_pfile); }
};

int Find_Comment_Start (FILE*&);
int Comment_Double_Shash_End (FILE*&);
int Comment_Star_Slash_End (FILE*&);

//The first element of the pair is the Error Number and the second one
//is the Line Number on which the error was found.
void Handle_Error (std::pair<unsigned int, unsigned int> Error_Data)
{
  //We use the previously set up Vector of errors to get the Error
  //String.
  std::cout<<"On line: "<<Error_Data.second<<std::endl;
  std::cout<<_evec.at (Error_Data.first)<<std::endl;
}


int Find_Comment_Start (FILE*& _pfile)
{
  int ch = getc (_pfile);

  while (!feof (_pfile))
    {
      //      std::cout<<"In the While Loop   ch == "<<(char)ch<<std::endl;
      bool Is_Slash = (ch == '/' ? true : false);
      if (Is_Slash) //The next Character may be a Slash or a Star.
	{
	  //std::cout<<"ch is: "<<(char)ch<<std::endl;
	  //	  int old_ch = ch;
	  ch = getc (_pfile);
	  if (feof (_pfile))
	    {
	      Handle_Error (std::make_pair (1, 0));
	      return 1;
	    }
	  else if (ch == '/')
	    {
	      //Yippie! A double slash comment has been found.
	      if (fsm_vec[0] (_pfile))
		{
		  Handle_Error (std::make_pair (1, 0));
		  return 1;
		}
	    }
	  else if (ch == '*')
	    {
	      //A Slash Star Comment has been found.
	      if (fsm_vec[1] (_pfile))
		{
		  Handle_Error (std::make_pair (1, 0));
		  return 1;
		}
	    }
	  else
	    //Nothing Special. Just write the 2 charactrs to the file.
	    {
	      //std::cout<<"Writing Data to FILE..."<<std::endl;
	      assert (ch != '/');
	      //	      assert (old_ch != '/');

// 	      if (old_ch != '/')
// 		fputc (old_ch, _dest);
	      fputc (ch, _dest);
	    }
	  ch = getc (_pfile);
	}
      else
	{
	  //The character is not a slash. We check if it is a Double
	  //Quotation mark. If so, we eat right upto but not including
	  //the next Quotation Mark. Basically, we just dump all those
	  //characters to the Output File.
	  if (ch == '"')
	    {
	      fputc (ch, _dest);
	      if (fsm_vec[2] (_pfile))
		{
		  Handle_Error (std::make_pair (1, 0));
		  return 1;
		}
	      fputc ('"', _dest);
	    }
	  else
	    //Just write this character to the Output File.
	    {
	      //	      std::cout<<"Writing Data to FILE1..."<<(char)ch<<std::endl;
	      assert (ch != '/');
	      fputc (ch, _dest);
	    }
	  ch = getc (_pfile);
	}
    }
  return 0;
}

int Comment_Double_Shash_End (FILE*& _pfile)
{
  int ch = getc (_pfile);
  
  while (true)
    {
      if (feof (_pfile))
	return 1;
      else if (ch == '\n')
	{
	  fputc ('\n', _dest);
	  return 0;
	}
      else
	ch = getc (_pfile);
    }
}

int Comment_Star_Slash_End (FILE*& _pfile)
{
  int ch = getc (_pfile);
  if (feof (_pfile))
    return 1;
  
  while (true)
    {
      int old_ch = ch;
      ch = getc (_pfile);
      if (feof (_pfile))
	  return 1;

      if (old_ch == '*' && ch == '/')
	return 0;
    }
}


int Eat_Double_Quote (FILE*& _pfile)
{
  int ch = getc (_pfile);
  
  while (true)
    {
      if (feof (_pfile))
	return 1;
      else if (ch == '"')
	return 0;
      else
	{
	  fputc (ch, _dest);
	  ch = getc (_pfile);
	}
    }
}

void Map_Error_Vector (std::vector<std::string>& _evec_str)
{
  _evec_str.clear ();
  _evec_str.push_back ("");
  _evec_str.push_back ("Unexpected End of File Encountered.");
}

void Map_FSM_Vector (std::vector<Action>& _avec)
{
  _avec.clear ();
  _avec.push_back (&Comment_Double_Shash_End);
  _avec.push_back (&Comment_Star_Slash_End);
  _avec.push_back (&Eat_Double_Quote);
}


int main (int arg_num, char *args[])
{
  if (arg_num < 3)
    {
      std::cerr<<"Too Few Arguments."<<std::endl;
      return 4;
    }

  _dest = fopen (args[2], "w");
  if (!_dest)
    {
      std::cerr<<"Error Opening Output File"<<std::endl;
      std::cerr<<"Bailing out..."<<std::endl;
      return 2;
    }
  //First, we lock the File, so if there are any errors, then the file
  //will be closed properly.
  RAII_File Dest_File_Lock (_dest);

  FILE* _src = fopen (args[1], "r");
  if (!_src)
    {
      std::cerr<<"Error Opening Input File"<<std::endl;
      std::cerr<<"Bailing out..."<<std::endl;
      return 3;
    }
  //First, we lock the File, so if there are any errors, then the file
  //will be closed properly.
  RAII_File Src_File_Lock (_src);

  //Ok, So far, so good! Now, we set up the Error handling Vector of
  //Strings, and the FSM Vector that handles the various Events.
  Map_Error_Vector (_evec);
  Map_FSM_Vector (fsm_vec);

  //Call the Work Horse!
  return Find_Comment_Start (_src);
  //  fclose (_dest);
}