/*
 * Created on 2004-7-27
 *
 * To change the template for this generated file go to
 * Window>Preferences>Java>Code Generation>Code and Comments
 */
package boggle.model;
import mvc143.*;

import java.util.Random;
import java.io.*;
import java.util.HashSet;
import java.util.List;
import java.util.ArrayList;
import java.util.Collection;
/**
 * @author xm
 *
 */
public class BoggleModel implements IBoggleModel{
 public static final String author = "X. Miao";
 public static final String description = "the model";

 /* (non-Javadoc)
  * @see mvc143.IBoggleModel#createBoard(java.net.URL)
  */
 private static final char[] alphabet = {'A','B','C','D','E','F','G','H','I','J', 
 'K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'};
 private char[][] board;
 private int cols;
 private int rows;
 private int score;
 private IBoggleWordsModel theDictModel;

 
 public BoggleModel(String boardFile,String dictFile,int rows,int cols){
 this.cols = cols;
 this.rows = rows;
  score = 0; 
  theDictModel = new BoggleWordsModel(dictFile);
  createBoard(boardFile);
 }
 
 
 public boolean createBoard(String fileID) {
  board = new char[rows][cols];
  if (fileID==null){
  	createBoard();
  }
  else{
    try{
    BufferedReader input = new BufferedReader(new FileReader(fileID));
    String str;
    int row = 0;
    while((str=input.readLine())!=null && row<rows){
      for (int col=0;col<cols;col++)
        board[row][col] = str.charAt(col);
      row++;
    }
    input.close();
    }
    catch(IOException e){
	  createBoard();
      System.out.println("Can't open the resource"+fileID);
    }
  }
  return true;
 }
 
 private void createBoard(){
	if (board == null)
		board = new char[rows][cols];
	Random r = new Random();
	for (int row=0;row<rows;row++){
	 for (int col=0;col<cols;col++){
	  	board[row][col] = alphabet[r.nextInt(26)]; 
	 }
	}
 }

 /* (non-Javadoc)
  * @see mvc143.IBoggleModel#getLetter(int, int)
  */
 public int getLetter(int row, int col) {
  if (col<cols && col>=0 && row<rows && row >=0)
   return board[row][col];
  else
   return -1;
 }

 /* (non-Javadoc)
  * @see mvc143.IBoggleModel#getcols()
  */
 public int getCols() {
  return cols;
 }

 /* (non-Javadoc)
  * @see mvc143.IBoggleModel#getrows()
  */
 public int getRows() {
  return rows;
 }

 /* (non-Javadoc)
  * @see mvc143.IBoggleModel#addScore(int)
  */
 public int addScore(int score) {
  return (this.score += score);
 }

 /* (non-Javadoc)
  * @see mvc143.IBoggleModel#getScore()
  */
 public int getScore(){
  return score;
 }
 
 public void resetScore(){
  score = 0;
 }


 public IBoggleWordsModel getWordsModel(){
 	return theDictModel;
 }
 
 public void terminate(){
  
 }
}

class BoggleWordsModel implements IBoggleWordsModel {

	private List proposalHistory = new ArrayList();;
	private HashSet dict;
	private int lastrow, lastcol;
	private boolean newproposal = true;
	private List history;
	
	public BoggleWordsModel(String fileID){
		loadDictionary(fileID);
		history = new ArrayList();
	}
	/* (non-Javadoc)
	 * @see mvc143.IBoggleDictionaryModel#loadDictionary(java.net.URL)
	 */
	public boolean loadDictionary(String fileID) {
		String str;
		dict  = new HashSet();
		if (fileID==null){
			return false;
		}
		try 
		{
		 BufferedReader input = new BufferedReader(new FileReader(fileID));
		 while ((str = input.readLine())!= null)
		 {
		  dict.add(str.toUpperCase());
		 }
		 // Close input stream
		 input.close();
		 return true;
		}
		catch (FileNotFoundException fe) 
		{
		 System.out.println("Error reading file; file not found");
		 return false;
		}
		catch (IOException e) 
		{
		 System.out.println("An IOException occured");
		 e.printStackTrace();
		 return false;
		}
	}


	/* (non-Javadoc)
	 * @see mvc143.IBoggleDictionaryModel#addToDictionary(java.lang.String)
	 */
	public void addToDictionary(String[] words){
	   for (int i=0;i<words.length;i++)
		   dict.add(words[i]);
	}

	/* (non-Javadoc)
	 * @see mvc143.IBoggleDictionaryModel#saveDictionary(java.net.URL)
	 */
	public void setDictionary(Collection dict){
	   this.dict = (HashSet)dict;
	}
 

 
	/* (non-Javadoc)
	 * @see mvc143.IBoggleDictionaryModel#isValidPosition(int, int)
	 */
	public boolean isValidPosition(int row, int col){
	  //if it is a new proposal , the letter is selected freely
	  if (newproposal){
		Pair v = new Pair(row,col);
		proposalHistory.clear();
		proposalHistory.add(v);
		lastrow = row;
		lastcol = col;
		proposalHistory.add(v);
		newproposal = false;
		return true;
	  }
	  //otherwise, here just check the adjency
	  if (Math.abs(lastcol-col)<2 && Math.abs(lastrow-row)<2){
		Pair v = new Pair(row,col);
		if (proposalHistory.contains(v))
			return false;
		lastrow = row;
		lastcol = col;
		proposalHistory.add(v);
		return true;
	  }
	  else
		return false; 
	}
 
	/**
	 * determine if the word proposed is valid or not. 
	 * @param proposal, a String
	 * @return proposal itself, if it is valid;
	 *         an error message, otherwise;
	 * 0 if the word is valid; 1 if the word if not in the 
	 * dictionary; 2 if the word is a duplicate.  Other values also
	 * indicate failure but are not defined.
	 */
	public int isValidWord(String proposal){
	  newproposal = true;
	  if (!isInDictionary(proposal))
		return 1;
	  if (isDuplicate(proposal))
		 return 2;
	  history.add(proposal);
	  return 0;
	}
	
	/* (non-Javadoc)
	 * @see mvc143.IValidWordChecker#isDuplicate(java.lang.String)
	 */
	private boolean isDuplicate(String proposal) 
	{
	 if (history.contains(proposal))
	  return true;
	 else
	 {
	  history.add(proposal);
	  return false;
	 }
	}
	
	/* (non-Javadoc)
	 * @see mvc143.IValidWordChecker#isInDictionary(java.lang.String)
	 */
	private boolean isInDictionary(String proposal) 
	{
	 if (dict!=null)
	 return dict.contains(proposal);
	 else
	 return false;
	}


	/**
	 * get a history of all accepted words 
	 * @return a List containing all the accepted words
	 */
	public List getHistory(){
		return history; 
	}
	/**
	 * empty the history list
	 *
	 */
	public void emptyHistory(){
		history.clear();
	}
	/**
	 * add the accepted proposal to the history
	 *@param acceptedPorposal, a string that to be added to the history
	 */
	public void addToHistory(String acceptedProposal){
		history.add(acceptedProposal);
	}
	
	class Pair implements Comparable{
		int row;
		int col;
		public Pair(int row, int col){
			this.row = row;
			this.col = col;
		}
		
		public boolean equals(Object obj){
			Pair p = (Pair)obj;
			if (p.row == this.row && p.col == this.col)
				return true;
			else
				return false;
		}
		
		public int compareTo(Object obj){
			Pair p = (Pair)obj;
			if (p.row == this.row && p.col == this.col)
				return 0;
			if (p.row >= this.row)
				return 1;
			else if (p.col >= this.col)
				return 1;
			else
				return -1;
		}
	}

}