/**
 * The class <code>EnigmaMachine</code> implements an enigma machine with 
 * three rotors known as enigma machine M3.
 * It is comprised of one plugboard, 3 rotors (out of 5 types of rotors)
 * and one reflector (out of two types of reflectors).
 * Below we call the Right, Middle and Left rotors as 
 * rotor1, rotor2 and rotor3, respectively.
 * 
 * @author Lucia Moura
 *
 */


public class EnigmaMachine {


	/**
	 * An array that stores rotors 1, 2, 3 in positions 0, 1, 2, respectively.
	 */
	private Rotor[] rotors;
	
	/**
	 * The reflector of this enigma machine.
	 */
	private Reflector reflector;
	

	/**
	 * The plugboard of this enigma machine.
	 */
	private PlugBoard plugBoard;
	
	/**
	 * An auxiliary boolean variable indicating if stepping is enabled.
	 */
	private boolean stepping=true;
	
	
	/**
	 * A constructor of arity 0 that sets the machine to default values:
	 * rotors RML are types I, II, III, reflector is type B
	 * rotor positions AAA
	 */
	public EnigmaMachine() {
		this(1,2,3,1,'A','A','A');	
	}
	
	/**
	 * A constructor of arity 4 that sets the machine to given 
	 * rotor and refletor types; rotor positions set to default values AAA.
	 * 
	 * @param rotor1Type is the type of the right  rotor (number 1..5)
	 * @param rotor2Type is the type of the middle rotor (number 1..5)
	 * @param rotor3Type is the type of the left   rotor (number 1..5)
	 * @param reflectorType is the type of reflector: 1 is type B, 2 is type C.
	 */
	public EnigmaMachine( int rotor1Type, int rotor2Type, int rotor3Type, 
			int reflectorType) {
		this(rotor1Type,rotor2Type,rotor3Type,reflectorType,
				'A','A','A');
	}
		
	
    /**
     * A constructor of arity 7 that sets the machine to given 
	 * rotor types, refletor type and rotor positions.
	 * 
     * @param rotor1Type is the type of the right  rotor (number 1..5)
     * @param rotor2Type is the type of the middle rotor (number 1..5)
     * @param rotor3Type is the type of the left   rotor (number 1..5)
     * @param reflectorType is the type of reflector: 1 is type B, 2 is type C.
     * @param startPos1 is the char position of the right rotor.
     * @param startPos2 is the char position of the middle rotor.
     * @param startPos3 is the char position of the left rotor.
     */
    public EnigmaMachine( int rotor1Type, int rotor2Type, int rotor3Type, 
    		int reflectorType, 
    		char startPos1, char startPos2, char startPos3) {
		
		// ADD YOUR CODE HERE
	}
	
	/**
	 * The method <code>enableStepping</code> sets the machine to allow the 
	 * rotors step according to the stepping rules. This should be the 
	 * default state of the machine.
	 */
	public void enableStepping() {
		// ADD YOUR CODE HERE
	}

	/**
	 * The method <code>disableStepping</code> sets the machine to disallow 
	 * the rotors stepping. This is used for testing purposes only so that 
	 * rotor encoding can be tested independently of the stepping mechanism.
	 */
	public void disableStepping() {
		// ADD YOUR CODE HERE
	}
	
	/**
	 * The method <code>setInitialRotorPositions</code> initializes the 
	 * initial position of the rotors for the next encoding to be as given.
	 * Historically in WWW2, rotor and reflector types where changed daily
	 * while rotor positions where changed for each message transmitted.
	 * 
	 * @param letter1 is the initial position for the right rotor (rotor1)
	 * @param letter2 is the initial position for the middle rotor (rotor2)
	 * @param letter3 is the initial position for the left rotor (rotor3)
	 */
	public void setInitialRotorPositions(char letter1, char letter2, char letter3) {
		// ADD YOUR CODE HERE
	}
	
	/**
	 * The method resetRotorPositions brings the rotor positions to their
	 * initial rotor position values. This "initial rotor position" is set 
	 * at machine creation and may have been updated by a former call to 
	 * setInitialRotorPositions().
	 * This  has been provided to facilitate resending the same message 
	 * or testing the decoding of the last message sent.
	 * 
	 */	
	public void resetRotorPositions() {
		// ADD YOUR CODE HERE		
	}
	
	
	/**
	 * The method <code>plug</code> plugs the two given letters in the 
	 * plugboard.
	 * 
	 * @param letter1 is a letter to be plugged to the other letter given.
	 * @param letter2 is a letter to be plugged to the other letter given.
	 */
	public void plug(char letter1, char letter2) {
		// ADD YOUR CODE HERE
	}

	

	/**
	 * This method <code>encrypt</code> performs the encoding of one letter
	 * going through the enigma machine, executing the letter trip through 
	 * the various machine elements, until it gets encoded as a new output 
	 * letter that is returned.
	 * Note: the stepping of the rotos is done before the character travels
	 * through the rotors.
	 * 
	 * @param letter is the input letter (a capital letter from 'A' to 'Z')
	 * @return the output encoded letter (a capital letter from 'A' to 'Z')
	 */
	public char encrypt(char letter) {
		
		// ADD YOUR CODE HERE
		// the method is incorrectly returning always letter 'A'
		
		return 'A';
	}

	
	/**
	 * This method <code>encrypt</code> performs the encoding of a whole
	 * text going through the enigma machine, by sucessive calling the
	 * encoding of each of its individual letters.
	 * 
	 * @param text is the input text consisting only of capital letters ('A' to 'Z')
	 * @return is the output encoded text
	 */
	public String encrypt(String text){
		// leave this method as is
		String output=new String("");
		for (int i=0; i<text.length();i++) 
			output = output + encrypt(text.charAt(i));
		return output;
		
	}
		

	
	/**
	 * The method <code>stepRotors</code> controls the stepping of
	 * the 3 rotors from right to left always stepping the right
	 * rotor (rotor1) and sometimes stepping rotors 2 and 3 depending
	 * on the position of the previous rotor relatively to their notch
	 * position. This method does nothing if stepping has been disabled.
	 */
	private void stepRotors() { 
		// ADD YOUR CODE HERE
		// this is an auxiliary method to be called by encrypt(char)
		// recall that rotor rotation must done before the incoming letter 
		// goes through the rotors.
	
	}
	
    /**
     * This method overrides java.lang.Object.toString() and 
     * returns a string representation of this <code>EnigmaMahine</code>.
     * 
     * @return a string representation of this <code>EnigmaMahine</code>
     */	
	
	public String toString() {
		// here we have provided a standard output format uniform for 
		// all students; please do not alter this format.
		// as it is given in the line below it would give now a run time
		// error for rotors is a reference to an array that must be created
		// return "EnigmaMachine:\n"+rotors[0]+"\n"+rotors[1]+"\n"+rotors[2]
		//	 +"\n"+reflector+"\n"+plugBoard+"\n";
		
	    // below is a dummy return so that this code compiles
	    return "EnigmaMachine: dummy values\n";
	}
	
};