import java.applet.Applet;
import java.awt.*;

//===========================================
public class CatchFox extends Applet {

   public static int DIMENSION=10; //Warning! Dimension cannot be more than 10;
         // Otherwise pnlForest.action and pnlForest.FindIndexes will not work.
   public static int FOXQNTTY=5;
   public static int FOX=FOXQNTTY+1;
   public static int Forest[][]=new int[DIMENSION][DIMENSION];
   static PanelMonitor pnlMonitor;
   static PanelControl pnlControl; 
   static PanelForest pnlForest;
//   static PanelM pnlM;
   
   public static int StepCounter;
   public static int CaughtFoxesCounter;
   
   //----------------------------
   
   public void init() {
   
      setLayout(new BorderLayout());
      setBackground(Color.gray);
      add("North", pnlMonitor=new PanelMonitor());
      add("South",pnlControl=new PanelControl());
      add("Center", pnlForest=new PanelForest());
      add("West", new Panel());
      add("East", new Panel());
      
   
   }
   
   //----------------------------
   
      public void start() {
      
         StartNewGame();
         repaint();     
      
      }
   
   //----------------------------
   
   public void update(Graphics g) {
   
      paint(g);
   
   }
   
   //----------------------------
   
   public void paint(Graphics g) {
   
   
   
/*      for(int i=0;i<DIMENSION;i++)
         for(int j=0;j<DIMENSION;j++)
            DrawForest(Forest[i][j],i,j);
*/   
   }
   
   //----------------------------
   
   public static void StartNewGame() {
   
      InitForest();
      for(int i=0;i<FOXQNTTY;i++)
         DropFoxes();
      
   
   }
   
   //----------------------------
   
   private static void InitForest() {
   
      StepCounter=0;
      CaughtFoxesCounter=FOXQNTTY;
      pnlMonitor.lblStep.setText("0");
      Font Temp=new Font(pnlMonitor.getFont().getName(),Font.BOLD,
                           pnlMonitor.getFont().getSize());
      pnlMonitor.setFont(Temp);                     
      pnlMonitor.lblCaughtFoxes.getGraphics().setColor(Color.white);
      pnlMonitor.lblCaughtFoxes.setText(Integer.toString(FOXQNTTY));
      
      pnlControl.MarkFlag=false;
      pnlControl.btnMarkSure.setLabel("Mark/Unmark Empty Cells");
      pnlControl.FinishedFlag=false;
      
      
   
      for(int i=0;i<DIMENSION;i++)
         for(int j=0;j<DIMENSION;j++) {
            Forest[i][j]=-1;     
            pnlForest.btnForest[i][j].setLabel("");
            Font Temp2=new Font(pnlForest.btnForest[i][j].getFont().getName(),Font.PLAIN,
               pnlForest.btnForest[i][j].getFont().getSize());
            pnlForest.btnForest[i][j].setFont(Temp2);
         }                                         
               
   }
   
   //----------------------------
   
//   private void DrawForest(int ForestCell, int Column, int Row) {
   
//      if(ForestCell>=0)
//         RedrawForestCell(Column,Row);
   
//   }
   
   //----------------------------
   
   private static void DropFoxes() {
   
      int Position;
      try {
         Position=(int)Math.abs(DIMENSION*DIMENSION*(Math.random()-0.0001));
         if(Forest[Position/DIMENSION][Position%DIMENSION]>0)
            DropFoxes();
         else
            Forest[Position/DIMENSION][Position%DIMENSION]=FOX;
      }
      catch(ArrayIndexOutOfBoundsException e){DropFoxes();}
         // very crazy recursion
   
   }
   
   //----------------------------
   
   public static void IncreaseStep() {
   
      StepCounter++;
      pnlMonitor.lblStep.setText(Integer.toString(StepCounter));
                                                  
   }
   
   //----------------------------
   
   public static void DecreaseFoxCounter() {
   
      CaughtFoxesCounter--;
      pnlMonitor.lblCaughtFoxes.setText(Integer.toString(CaughtFoxesCounter));
      if(CaughtFoxesCounter==0)
         Congratulations();
      
   }
   //----------------------------
   
   private static void Congratulations() {
   
      int i,j;
      
      pnlControl.FinishedFlag=true;
      
      Font Temp=new Font(pnlForest.getFont().getName(),(Font.BOLD),pnlForest.getFont().getSize());
      for(i=0;i<DIMENSION;i++)
         for(j=0;j<DIMENSION;j++) {
            Forest[i][j]=0;
            pnlForest.btnForest[i][j].setLabel("");
            pnlForest.btnForest[i][j].setFont(Temp);
            pnlForest.btnForest[i][j].setForeground(Color.blue);
            
            
         }
               // following actions are prohibited
      
      for(i=1;i<9;i++) {
         pnlForest.btnForest[3][i].setLabel("*");
         pnlForest.btnForest[5][i].setLabel("*");
      }
      pnlForest.btnForest[4][1].setLabel("*");
      pnlForest.btnForest[4][8].setLabel("*");
      
      pnlForest.btnForest[4][2].setLabel("D");
      pnlForest.btnForest[4][3].setLabel("o");      
      pnlForest.btnForest[4][4].setLabel("n");         
      pnlForest.btnForest[4][5].setLabel("e");      
      pnlForest.btnForest[4][6].setLabel("!");
      pnlForest.btnForest[4][7].setLabel("!");
   
   }
   //----------------------------

}
//===========================================

class PanelForest extends Panel {

   public static Button btnForest[][]=new Button[CatchFox.DIMENSION][CatchFox.DIMENSION];
   

   //-----------------------------
   
   public PanelForest() {
   
      reshape(0,0,250,250);
      setLayout(new GridLayout(CatchFox.DIMENSION,CatchFox.DIMENSION));
      for(int i=0;i<CatchFox.DIMENSION;i++)
         for(int j=0;j<CatchFox.DIMENSION;j++) 
            add(btnForest[i][j]=new Button(""));
   }

   //-----------------------------
   
   public boolean action(Event e, Object o) {
   
      if(e.target instanceof Button) {
      
         int Negotiator=FindIndexes(e);
         int Column=Negotiator/CatchFox.DIMENSION;
         int Row=Negotiator%CatchFox.DIMENSION;
  
                
         if(!CatchFox.pnlControl.MarkFlag) {       
         if(((CatchFox.Forest[Column][Row]<0)||(CatchFox.Forest[Column][Row]==CatchFox.FOX))&&
            ((String)o!="X")&&
            ((String)o!="Fox")) {
//            if(e.clickCount<2) {
               ShowCell(CatchFox.Forest[Column][Row],Column,Row);
               CatchFox.IncreaseStep();
//            }
//            else {
//               MarkForSure(Column,Row);
//            }
         }
         }
         else if((String)o!="Fox") {
            MarkForSure(Column,Row);
         }
      
      }                       
      
      
      return true;      
   }
   //-----------------------------
   
   private void MarkForSure(int Column,int Row) {
   
      Font Temp=new Font(getFont().getName(),Font.PLAIN,getFont().getSize());
      btnForest[Column][Row].setFont(Temp);
      btnForest[Column][Row].setForeground(Color.green.darker());

      if(btnForest[Column][Row].getLabel()=="X") {
         btnForest[Column][Row].setLabel("");
         if(CatchFox.Forest[Column][Row]!=CatchFox.FOX)
            CatchFox.Forest[Column][Row]=-1;
         
      }
      else 
         btnForest[Column][Row].setLabel("X");
      
   }
   //-----------------------------
   
   private int FindIndexes(Event e) {
   
      int Column=0;
      int Row=0;
      for(int i=0;i<CatchFox.DIMENSION;i++)
         for(int j=0;j<CatchFox.DIMENSION;j++)
            if(e.target.equals(btnForest[i][j])) {
               Column=i;
               Row=j;
            }
      
      return Column*CatchFox.DIMENSION+Row;
      
   }
   //-----------------------------
                                                                     
   private void ShowCell(int CheckedCell,int Column, int Row) {
   
      Font Temp=new Font(getFont().getName(),Font.BOLD,getFont().getSize());
      btnForest[Column][Row].setFont(Temp);
      if(CheckedCell!=CatchFox.FOX) {
         int FoxesAround=CountFoxes(Column,Row);
         btnForest[Column][Row].setLabel(Integer.toString(FoxesAround));
         CatchFox.Forest[Column][Row]=FoxesAround;
      }
      else {
         CaughtFox(Column,Row);
         CatchFox.DecreaseFoxCounter();
      }
     
      
   }
   
   //-----------------------------
   
   private int CountFoxes(int Column, int Row) {
   
      return HorizontalFoxes(Row)+
             VerticalFoxes(Column)+  
             DOSDiagonalFoxes(Column,Row)+  // correct(?)
             UNIXDiagonalFoxes(Column,Row);
            
   }
   
   //-----------------------------
   
   private int HorizontalFoxes(int Row) {
   
      int Foxes=0;
      for(int i=0;i<CatchFox.DIMENSION;i++)
         if(CatchFox.Forest[i][Row]==CatchFox.FOX)
            Foxes++;
      return Foxes;          
   }

   //-----------------------------
   
   private int VerticalFoxes(int Column) {
   
      int Foxes=0;
      for(int j=0;j<CatchFox.DIMENSION;j++)
         if(CatchFox.Forest[Column][j]==CatchFox.FOX)
            Foxes++;
      return Foxes;          
   }                                  
   
   //-----------------------------
   
   private int DOSDiagonalFoxes(int Column,int Row) {
   
      int Foxes=0;
      int i=0,j=0;

      if(Row>Column)
         j=Row-Column;
      else 
         i=Column-Row;
      
      while((i<CatchFox.DIMENSION)&&
            (j<CatchFox.DIMENSION)&&
            (i>=0)&&(j>=0)) {
         if(CatchFox.Forest[i][j]==CatchFox.FOX)
            Foxes++;
         i++;
         j++;
      }
      
      return Foxes;
      
   }
   
   //-----------------------------
   
   private int UNIXDiagonalFoxes(int Column,int Row) {
   
      int Foxes=0;
      int i=Column;
      int j=Row;
      
      while((i>=0)&&(j<CatchFox.DIMENSION)) {
         if(CatchFox.Forest[i][j]==CatchFox.FOX)
            Foxes++;
         i--;
         j++;
      }
      
      i=Column;
      j=Row;
      while((i<CatchFox.DIMENSION)&&(j>=0)) {
         if(CatchFox.Forest[i][j]==CatchFox.FOX)
            Foxes++;
         i++;
         j--;
      }
      
      return Foxes;
      
   }
   //-----------------------------
   private void CaughtFox(int Column, int Row) {
   
      btnForest[Column][Row].setForeground(Color.red);
      btnForest[Column][Row].setLabel("Fox");
   }
   
   //-----------------------------
}

//===========================================

class PanelMonitor extends Panel {

   public Label lblStep;
   public Label lblCaughtFoxes;
   
   //-----------------------------
   
   public PanelMonitor() {
   
      add(new Label("Step:"));
      add(lblStep=new Label("0"));
      add(new Label("       "));
      add(new Label("Hidden Foxes:"));
      add(lblCaughtFoxes=new Label(Integer.toString(CatchFox.FOXQNTTY)));
      
   }
   
   //-----------------------------
}
//===========================================

class PanelControl extends Panel {
   
   private static Button btnNewGame;
   public static Button btnMarkSure;
   public static boolean MarkFlag=false;
   public static boolean FinishedFlag=false;
   
   //-----------------------------
   
   public PanelControl() {
   
      add(btnNewGame=new Button("New Game"));
      add(btnMarkSure=new Button("Mark/Unmark Empty Cells"));
   }
   
   //-----------------------------
   
   public boolean action(Event e, Object o) {
   
      if(e.target.equals(btnNewGame)) {
         CatchFox.StartNewGame();
      }
      else if (e.target.equals(btnMarkSure)) {
         if(!FinishedFlag) {
            if(!MarkFlag){
               Graphics g=btnMarkSure.getGraphics();
               g.setColor(Color.red);
               g.fillRoundRect(5,5,4,4,4,4);
               btnMarkSure.setLabel("Stop Marking");
            }
            else 
               btnMarkSure.setLabel("Mark/Unmark Empty Cells");
            MarkFlag=!MarkFlag;
         }
      }
      
      return true;
   }
   
   //-----------------------------



}
//===========================================
/* 
class PanelM extends Panel {

   static public Label lblM1;
   static public Label lblM2;
   static public Label lblM3;
   static public Label lblM4;
   
   public PanelM() {
   
      setLayout(new GridLayout(4,1));
      add(lblM1=new Label("1000"));
      add(lblM2=new Label("1000"));
      add(lblM3=new Label("1000"));
      add(lblM4=new Label("1000"));
   
   }
   
   
}
*/
//===========================================