/*
  A robot is defined by: 
        its name (e.g. "XJ47" or "Bumblebee"), 
        its power-level (47 or 850), 
        what shape it can transform into (a toaster, or a VW Beetle), 
        whether it is currently transformed (true or false), 
        and whether it's evil (false or true).

   - Make a constructor (using, for now, the same boilerplate pattern as we did for Song). 

   - Make a `void testAll()`, which for now just has 2-3 examples of Robot objects.
   


   - write a function: currentShape:
     takes in a Robot, returns its current shape,
     (either "Robot" or its transfromed shape, depending on whether it's currently transformed.)
     Note: name your parameter `thiss`.

   - write a function: strongerOf, which takes in two Robots, and returns
     the one that has a higher power-level.
     (In case of a tie, use the first one).

   - write a function `toString` that takes in a robot,
     and returns either
        "The autobot Bumblebee!"    (use "autobot" for non-evil, and "decepticon" for evil)
        "a regular-looking toaster."
*/
class Robot {
    private String name;
    private int power;
    private String shape;
    private boolean isTransformed;
    private boolean isEvil;
    
    public Robot( String n, int p, String s, boolean isT, boolean isE ) {
        this.name = n;
        this.power = p;
        this.shape = s;
        this.isTransformed = isT;
        this.isEvil = isE;
    }
    
    
    public String toString( /* Robot2 this */ ) {
        if (this.isTransformed) {
            return "A regular-looking " + this.shape + ".";
        }
        else {
            return "The "
                 + (this.isEvil  ?  "decepticon"  :  "autobot") 
                 + " " 
                 + this.name + "!";
        }
        
    }
    
    /** Does `this` want to fight `that`? */
    boolean wouldFight( /* Robot this, */ Robot that ) { return true; }
    
    /** Does `this` want to fight any of `them`? */
    boolean wouldFight( /* Robot this, */ Robot[] them ) {
        boolean haterSoFar = false;
        for (int i=0;  i<them.length  && !haterSoFar;  i+=1) {
            haterSoFar = haterSoFar || this.wouldFight(them[i]);
            }
        return haterSoFar;
        }

    /** Are *any* two Robots in `clique` itchin' to fight each other? */
    static boolean gonnaBeAFight( Robot[] clique ) { 
        boolean tensionSoFar = false;
        for (  int i=0;  i<clique.length && !tensionSoFar;  ++i ) {
            tensionSoFar = tensionSoFar || clique[i].wouldFight(clique);
        }
        return tensionSoFar;
        
        // N.B.  Once we right the slightly-more-general version (below),
        // this would refactored into just one line:
        //     return clanHasAHaterOf( clique, clique );
    }
      
        
        
        
    
    
    
        
    /** Is *any* Robot in `home` itchin' to fight a Robot of `away`? 
     * (not necess. vice-versa)
     */
    static boolean clanHasAHaterOf( Robot[] home, Robot[] away ) {
        boolean tensionSoFar = false;
        for (  int i=0;  i<home.length && !tensionSoFar;  i+=1 ) {
            tensionSoFar = tensionSoFar || (home[i]).wouldFight( away );
        }
        return tensionSoFar;
    }
    
    /** Is *any* Robot in `home` itchin' to fight a Robot of `away`? 
     * (not necess. vice-versa)
     */
    static boolean gonnaBeAFight( Robot[] home, Robot[] away ) {
        return clanHasAHaterOf(home,away) || clanHasAHaterOf(away,home);
    }
    
    void testAll() {
        Robot r2 = new Robot("R2D2", 7, "trashbin", false, false);
        Robot r3 = new Robot("Maria", 101, "woman", false, true); // https://en.wikipedia.org/wiki/Maschinenmensch
        Robot op = new Robot("Optimus Prime", 835, "tractor-trailer", true, false);
        Robot mg = new Robot("Megatron", 835, "laser cannon", true, false);
       
        Object120.assertEquals( r2.toString(), "The autobot R2D2!" );
        Object120.assertEquals( r3.toString(), "The decepticon Maria!" );
        Object120.assertEquals( op.toString(), "A regular-looking tractor-trailer." );
        Object120.assertEquals( mg.toString(), "A regular-looking laser cannon." );
        
    }
    
}