Tile

package jpp.infinityloop.basics;

import java.util.ArrayList;

public class Tile {

    private TileType tileType;
    private Orientation [] orientation;
    private CoordinatesOfTile coord;
    private final Orientation [] initOrientation;

    public Tile(TileType tileType, Orientation [] orientation){
        this.tileType = tileType;
        this.orientation = orientation;
        this.initOrientation = orientation;
    }

    public Tile(CoordinatesOfTile coord, TileType tileType, Orientation orientation){
        this.tileType = tileType;
        this.orientation = new Orientation[1];
        this.orientation[0] = orientation;
        this.coord = coord;
        this.initOrientation = new Orientation[1];
        this.initOrientation[0] = orientation;
    }

    public Tile(CoordinatesOfTile coord,TileType tileType, Orientation [] orientation){
        this.tileType = tileType;
        this.orientation = orientation;
        this.coord = coord;
        this.initOrientation = orientation;
    }

    public Tile getRotatedTile(){
        switch(this.tileType){
        case DEAD_END:
            return new Tile(this.tileType,rotateDeadEnd());
        case BEND:
            return new Tile(this.tileType,rotateBend());
        case TEE:
            return new Tile(this.tileType,rotateTee());
        case STRAIGHT:
            return new Tile(this.tileType,rotateStraight());
        default:
            return this;
        }
    }

    public TileType getType(){
        return this.tileType;
    }

    public Orientation [] getInitOrientation(){
        return this.initOrientation;
    }

    public boolean hasConnectionTo(Orientation neighbor){
        Orientation counter = neighbor.findCounterpart();
        switch(this.tileType){
        case DEAD_END:
            for(int i = 0; i < orientation.length; i++){
                if(orientation[i] == counter){
                    return true;
                }
            }
            return false;
        case BEND:
            switch(orientation[0]){
            case RIGHT:
                if(counter == Orientation.RIGHT || counter == Orientation.DOWN){
                    return true;
                }else
                    return false;
            case DOWN:
                if(counter == Orientation.LEFT || counter == Orientation.DOWN){
                    return true;
                }else
                    return false;
            case UP:
                if(counter == Orientation.RIGHT || counter == Orientation.UP){
                    return true;
                }else
                    return false;
            default:
                if(counter == Orientation.LEFT || counter == Orientation.UP){
                    return true;
                }else
                    return false;
            }
        case TEE:
            switch(orientation[0]){
            case RIGHT:
                if(counter != Orientation.UP) return true;
                else return false;
            case UP:
                if(counter != Orientation.LEFT) return true;
                else return false;
            case LEFT:
                if(counter != Orientation.DOWN) return true;
                else return false;
            default:
                if(counter != Orientation.RIGHT) return true;
                else return false;
            }
        case STRAIGHT:
            for(int i = 0; i < orientation.length; i++){
                if(orientation[i] == counter){
                    return true;
                }
            }
            return false;
        case CROSS:
            return true;
        default:
            return false;
        }
    }

    public void reset(){
        if(!this.orientation.equals(this.initOrientation)){
            this.orientation = initOrientation;
        }
    }

    public Orientation []  getOrientation(){
        return this.orientation;
    }

    public void setCoord(CoordinatesOfTile newCoord){
        this.coord = newCoord;
    }

    public CoordinatesOfTile getCoord(){
        return this.coord;
    }

    public boolean sameOrientation(Orientation [] compareOre){
        if(this.orientation.length != compareOre.length){
            return false;
        }else{
            ArrayList<Orientation> compareList = new ArrayList<Orientation>();
            for(int i = 0;i<= compareOre.length-1;i++){
                compareList.add(compareOre[i]);
            }
            for(int i = 0;i<= this.orientation.length-1;i++){
                if(compareList.contains(this.orientation[i])){
                }else{
                    return false;
                }
            }
            return true;
        }
    }

    public String getOrientationAsString(){
        StringBuilder builder = new StringBuilder();
        for(int i = 0;i<= this.orientation.length-1;i++){
            builder.append(this.orientation[i] + " ");
        }
        return builder.toString();
    }

    public void rotate(){
        switch(this.tileType){
        case DEAD_END:
            this.orientation = rotateDeadEnd();
            break;
        case BEND:
            this.orientation = rotateBend();
            break;
        case TEE:
            this.orientation = rotateTee();
            break;
        case STRAIGHT:
            this.orientation = rotateStraight();
            break;
        default:
            break;
        }
    }

    public Orientation [] rotateDeadEnd(){
        Orientation [] orientationArr = new Orientation [1];
        switch(this.orientation[0]){
        case LEFT:
            orientationArr[0] = Orientation.UP;
            return orientationArr;
        case RIGHT:
            orientationArr[0] = Orientation.DOWN;
            return orientationArr;
        case DOWN:
            orientationArr[0] = Orientation.LEFT;
            return orientationArr;
        default:
            orientationArr[0] = Orientation.RIGHT;
            return orientationArr;
        }
    }

    public Orientation [] rotateBend(){
        Orientation [] orientationArr = new Orientation [1];
        switch(this.orientation[0]){
        case LEFT:
            orientationArr[0] = Orientation.UP;
            return orientationArr;
        case RIGHT:
            orientationArr[0] = Orientation.DOWN;
            return orientationArr;
        case DOWN:
            orientationArr[0] = Orientation.LEFT;
            return orientationArr;
        default:
            orientationArr[0] = Orientation.RIGHT;
            return orientationArr;
        }
    }

    public Orientation [] rotateTee(){
        Orientation [] orientationArr = new Orientation [1];
        switch(this.orientation[0]){
        case LEFT:
            orientationArr[0] = Orientation.UP;
            return orientationArr;
        case RIGHT:
            orientationArr[0] = Orientation.DOWN;
            return orientationArr;
        case DOWN:
            orientationArr[0] = Orientation.LEFT;
            return orientationArr;
        default:
            orientationArr[0] = Orientation.RIGHT;
            return orientationArr;
        }
    }

    public Orientation [] rotateStraight(){
        Orientation [] orientationArr = new Orientation [2];
        if(this.orientation[0].equals(Orientation.UP) && this.orientation[1].equals(Orientation.DOWN)
                || this.orientation[0].equals(Orientation.DOWN) && this.orientation[1].equals(Orientation.UP)) {
            orientationArr[0] = Orientation.LEFT;
            orientationArr[1] = Orientation.RIGHT;
            return orientationArr;
        }else if(this.orientation[0].equals(Orientation.LEFT) && this.orientation[1].equals(Orientation.RIGHT)
                || this.orientation[0].equals(Orientation.RIGHT) && this.orientation[1].equals(Orientation.LEFT)) {
            orientationArr[0] = Orientation.UP;
            orientationArr[1] = Orientation.DOWN;
            return orientationArr;
        }else{
            throw new IllegalArgumentException("Type Straight has false orientation!");
        }
    }

    public String toString(){
        StringBuilder builder = new StringBuilder();
        if(this.orientation.length == 1){
            builder.append("("+this.coord.getRow()+","+this.coord.getColumn()+") " + this.tileType.toString()  + " " + this.orientation[0]);
        }else if(this.orientation.length == 2){
            builder.append("("+this.coord.getRow()+","+this.coord.getColumn()+") " + this.tileType.toString() + " " + this.orientation[0] + " " + this.orientation[1]);
        }else if(this.orientation.length == 3){
            builder.append("("+this.coord.getRow()+","+this.coord.getColumn()+") " + this.tileType.toString() + " " + this.orientation[0] + " " + this.orientation[1] + " "
                    + this.orientation[2]);
        }else{
            builder.append("("+this.coord.getRow()+","+this.coord.getColumn()+") " + this.tileType.toString() + " " + this.orientation[0] + " " + this.orientation[1]
                    + " " + this.orientation[2] + " " +  this.orientation[3]);

        }
        return builder.toString();
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((coord == null) ? 0 : coord.hashCode());
        result = prime * result + ((tileType == null) ? 0 : tileType.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Tile other = (Tile) obj;
        if (coord == null) {
            if (other.coord != null)
                return false;
        } else if (!coord.equals(other.coord))
            return false;
        if (tileType != other.tileType)
            return false;
        if (!this.sameOrientation(other.getOrientation())){
            return false;
        }
        return true;
    }


}