#include <iostream>
#include <time.h>
#include <stdlib.h>

#include "griglia.h"

     Griglia::Griglia(int _altezza, int _larghezza) {
     
        altezza = ( _altezza<10 ? 10 : _altezza );
        larghezza = ( _larghezza<10 ? 10 : _larghezza );
        
        Posizione p;
        
        // tutte la posizioni vengono inizializzate come non appartenenti al percorso        
        for (int i=1; i<=altezza; i++)  
           for (int j=1; j<=larghezza; j++) { 
              p.setX(i);
              p.setY(j);
              grid[ p ] = true;
           }
 
	//per inizializzare i numeri casuali
        srand ( time( NULL ) );  
      
	Posizione pos_iniziale(rand() % altezza +1, rand() %larghezza +1);  // posizione iniziale casuale
	
        generaPercorso( pos_iniziale );                  
        androide = NULL;
     }
     
     
     void Griglia::generaPercorso( const Posizione& p ) {
                              
           Posizione current = p; 
           if ( !internoInGriglia(current) ) {
              current.setX(2);  // metto nel percorso la posizione iniziale di default (2,2),
              current.setY(2);  // ricorda che le posizioni adiacenti il bordo della griglia
                                // non possono essere nel percorso !!        
           }        
           inizio = current;  // fisso l'inizio del percorso; l'arrivo sara' fissato da genera()           
           
	   genera( current, current ); // chiamo genera() per generare la parte restante del percorso
      }
     
     bool Griglia::genera( const Posizione& da, const Posizione& a ) {
              
           Posizione vicini[4];
           Direzione d("SUD");
                    
           int i = rand() % 4;  // genero un indice casuale tra 0 e 3
           
           Posizione v;          
           v=a; v.moveTo(d);  vicini[i] = v; // metto in vicini[i] la posizione a sud di "a"
           
           d++;
           i = ( i==3 ? 0 : i+1 );
           v=a; v.moveTo(d);  vicini[i] = v;  // metto in vicini[i] la posizione a ovest di "a"
           
           d++;
           i = ( i==3 ? 0 : i+1 );
           v=a; v.moveTo(d);  vicini[i] = v;  // metto in vicini[i] la posizione a nord di "a"
           
           d++;
           i = ( i==3 ? 0 : i+1 );
           v=a; v.moveTo(d);  vicini[i] = v;  // metto in vicini[i] la posizione a est di "a"
                         
           if (   internoInGriglia(a) &&  // "a" deve essere interno nella griglia;
                  grid[a] &&   // "a" non deve essere gi�nel percorso;                   
                 ( !inPercorso(vicini[0]) || da == vicini[0] ) &&  // e poi controllo che i vicini (diversi 
                 ( !inPercorso(vicini[1]) || da == vicini[1] ) &&  // da "da") non siano gi�nel percorso ...
                 ( !inPercorso(vicini[2]) || da == vicini[2] ) &&  // ...
                 ( !inPercorso(vicini[3]) || da == vicini[3] ) )   // ...
           { 
               grid[ a ] = false;  // metto "a" nel percorso
               
               if ( !genera( a, vicini[0] ) )   // itero la generazione provando a turno ...
                  if ( !genera( a, vicini[1] ) )  // ognuna delle 4 direzioni ...
                     if ( !genera( a, vicini[2] ) )  // ...
                        if ( !genera( a, vicini[3] ) )  // ...
                           { arrivo = a; }  // se nessuna delle 4 direzioni pu�appartenere
                                            // al percorso posso fissare "a" come arrivo
                                            
               return true;  // siccome "a" �stata posta nel percorso, il passo 
                             // corrente ha avuto esito positivo
               
           } else 
               return false;
           
    }
     
     bool Griglia::inGriglia( const Posizione& p) { 
     
         Posizione pp = p;  
         return ( pp.getX() >= 1 && 
                  pp.getX() <= altezza && 
                  pp.getY() >= 1 && 
                  pp.getY() <= larghezza );
     } 
     
     bool Griglia::internoInGriglia( const Posizione& p) { 
     
         Posizione pp = p;  
         return ( pp.getX() > 1 && 
                  pp.getX() < altezza && 
                  pp.getY() > 1 && 
                  pp.getY() < larghezza );
     }   
     
     bool Griglia::inPercorso( const Posizione& p) {   
         return ( inGriglia(p) && !grid[p] );
     }
     
     
     void Griglia::inserisciRobot( Robot & r) {
            androide = & r;
            androide->setPosizione( inizio );
     }
               
     Posizione Griglia::getArrivo() {
        return arrivo;
     }
     
     
     void Griglia::disegna() {
        
        int n='^', s='v', e='>', o='<', m='X';  // codici ASCII dei caratteri usati per disegnare la
                                                // direzione del robot (n,s,e,o) e la posizione della
                                                // griglia (m) non appartenente al percorso
                                            
        char cn=(char)n, cs=(char)s, ce=(char)e, co=(char)o, cm=(char)m;
        
        char d;
        if ( androide != NULL ) {
           Direzione dd = androide->getDirezione();
           if ( dd.getDirezione() == "NORD" ) d = cn;
           else if ( dd.getDirezione() == "EST" ) d = ce;
           else if ( dd.getDirezione() == "SUD" ) d = cs;
           else d = co;
        }
        
        Posizione p;
        cout << "  ";  // per staccare la griglia da sinistra dello schermo
        for (int i=1; i<=altezza; i++) {
           for (int j=1; j<=larghezza; j++) { 
              p.setX(i);
              p.setY(j);
              
              if ( !grid[p] ) {
                 if ( (androide != NULL) && (androide->getPosizione() == p) ) cout << d;                 
                 else if ( p == inizio) cout << "I";
                 else if ( p == arrivo) cout << "A";
                 else cout << " "; 
              } 
              else {
                if ( (androide != NULL) && (androide->getPosizione() == p) ) cout << d;
                else cout << cm;
              }
           }
           cout << endl << "  "; // per staccare la griglia da sinistra dello schermo
        }  
        
        cout << endl << endl; 
     }