#ifndef REPLCHOICES_H
#define REPLCHOICES_H

// Spellcheck program: choosing replacements for misspelled words

#include "cs361set.h"
#include <string>
#include <vector>


// This class implements a policy for choosing "plausible"
// replacements for a misspelled word. Many such policies are possible.
// For example, we might choose words from the system dictionary that
// "look like" the misspelled word, or words from the system dictionary that
// "sound like" the misspelled word, or some combination of these.
//



 struct ReplacementChooserData;


class ReplacementChooser
{
public:
  typedef CS361Set<std::string> Dictionaries;

  // Plan for replacements to be suggested from the
  // given dictionary.
  ReplacementChooser(const Dictionaries& dictionary); // constructor
  ~ReplacementChooser(); // destructor


  // Choose some number of "plausible" replacements for the given word,
  // returning them in the order we want them listed to the user.
  std::vector<std::string> getPlausibleReplacements(const std::string& word)
    const;

private:
  ReplacementChooserData* d;
  // This is an ilustration of a common programming idiom in C++. Normally,
  // the implementing data structure for an ADT is visible in the private
  // portion of a class's .h file. Thus if the ADT designer wants to later
  // change the data structure, he/she must edit the .h file as well as the
  // .cpp file.  We can, at a slight cost, however, hide the data structure
  // from the .h file by placing the implementing data structure inside
  // another class/struct, and simply having a pointer to that class/struct
  // in the ADT.


  // Don't allow copying and assignment of this ADT
  ReplacementChooser(const ReplacementChooser&) {}
  void operator= (const ReplacementChooser&) {}

};


#endif

#include "replchoices.h"
#include "edit1.h"
#include "soundex.h"

#include <algorithm>
#include <map>

using namespace std;

// This class implements a policy for choosing "plausible"
// replacements for a misspelled word. Many such policies are possible.
// For example, we might choose words from the system dictionary that
// "look like" the misspelled word, or words from the system dictionary that
// "sound like" the misspelled word, or some combination of these.
//


 struct ReplacementChooserData
 {
/*!!
  This is the data structure for the "off-by-one-character"
  suggestion strategy.  You will want to replace this data members
  here by a multimap that maps soundex codes to words having that
  soundex.  Then rewrite the function bodies below accordingly.
 !!*/
  const ReplacementChooser::Dictionaries& dict;

  ReplacementChooserData(const ReplacementChooser::Dictionaries& d): dict(d) {}
 };

typedef multimap< ReplacementChooser, ReplacementChooserData, less <ReplacementChooser> > my_Map;
my_Map mm;
pair < multimap < string , string >::iterator, bool > d;


ReplacementChooser::ReplacementChooser(const Dictionaries& dictionary)
{
  // d = new ReplacementChooserData(dictionary);
  d = mm.insert(ReplacementChooser, ReplacementChooserData(dictionary));
}

ReplacementChooser::~ReplacementChooser()
{
  mm.clear();
}


// Choose some number of "plausible" replacements for the given word,
// returning them in the order we want them listed to the user.
vector<string> ReplacementChooser::getPlausibleReplacements
  (const string& word) const
{
  vector<string> replacements;

  for (Dictionaries::const_iterator w = d->dict.begin();
       w != d->dict.end(); ++w)
    {
      if (oneEditAway(word, *w))
	replacements.push_back (*w);
    }

  return replacements;
}

#include "soundex.h"
#include <algorithm>

//
// The Soundex code is a rather primitive way of encoding the way words
// (especially names) sound so that variant spellings of the same word may
// be identified by the same code.
//
// Traditional Soundex codes have 4 alphanumeric characters
//   1 Letter and 3 Digits
//  - The Letter of the word is the first character of the Soundex code.
//  - The 3 digits are defined sequentially from the word using the
//    Soundex Key below.
//  - Adjacent letters in the word which belong to the same Soundex Key
//    code number are assigned a single digit.
//  - If the end of the word is reached prior to filling 3 digits,
//    use zeroes to complete the code. All codes have only 4 characters,
//    even if the word is long enough to yield more.
//
//    The Soundex Key:
//     1: b p f v
//     2: c s k g j q x z
//     3: d t
//     4: l
//     5: m n
//     6: r
//     no code: a e h i o u y w


// This function computes an "extended" Soundex code of k code characters
// If k<0, the code returned contains as many characters as can be obtained
// from the word by the above rules without adding zeroes at the end.


using namespace std;

string extendedSoundex (const string& word, int k)
{
  //                   "abcdefghijklmnopqrstuvwxyz";
  static const char* keys  = " 123 12  22455 12623 1 2 2";

  string soundexCode;

  char lastCode = ' ';
  for (int i = 0; i < word.size(); ++i)
    {
      char c = word[i];
      //convert to lowercase, if necessary
      if (c >= 'A' && c <= 'Z')
	c += 'a' - 'A';

      if (i == 0)
	// First char of soundex code is the unencoded character
	soundexCode += c;
      else if (c >= 'a' && c <= 'z')
	{
	  // append the soundex character code
	  char soundexChar = keys[c - 'a'];
	  if (soundexChar != lastCode && soundexChar != ' ')
	    soundexCode += soundexChar;
	  lastCode = soundexChar;
	}
    }

  if (k >= 0)
    {
      if (soundexCode.size() > k)
	// truncate code to k characters
	soundexCode = soundexCode.substr(0, k);
      else
	// pad code with zeros
	soundexCode += string(k-soundexCode.size(), '0');
    }

  return soundexCode;
}

#include "replchoices.h"
#include "edit1.h"
#include "soundex.h"

#include <algorithm>
#include <map>

using namespace std;

// This class implements a policy for choosing "plausible"
// replacements for a misspelled word. Many such policies are possible.
// For example, we might choose words from the system dictionary that
// "look like" the misspelled word, or words from the system dictionary that
// "sound like" the misspelled word, or some combination of these.
//

 typedef multimap<string, string> my_map; //have a blank multimap of types stringx2 and load ReplacementChooser etc onto it.
 typedef multimap<string, string>::const_iterator it;
 my_map extendedSoundex(); //Will become key value of my_map

 struct ReplacementChooserData
 {
/*!!
  This is the data structure for the "off-by-one-character"
  suggestion strategy.  You will want to replace this data members
  here by a multimap that maps soundex codes to words having that
  soundex.  Then rewrite the function bodies below accordingly.
 !!*/
  const ReplacementChooser::Dictionaries& dict;

  ReplacementChooserData(const ReplacementChooser::Dictionaries& d): dict(d) {}


 };



ReplacementChooser::ReplacementChooser(const Dictionaries& dictionary)
{
   d = new ReplacementChooserData(dictionary);
   my_map::insert(extendedSoundex(stuff?), d); //to load the multimap 

}

ReplacementChooser::~ReplacementChooser()
{
  delete d; //destructor
}


// Choose some number of "plausible" replacements for the given word,
// returning them in the order we want them listed to the user.
vector<string> ReplacementChooser::getPlausibleReplacements    //Will handle this later
  (const string& word) const
{
  vector<string> replacements;
  

  for (Dictionaries::const_iterator w = d->dict.begin();
       w != d->dict.end(); ++w)
    {
      if (oneEditAway(word, *w))
	replacements.push_back (*w);
    }

  return replacements;
}