import java.util.Deque;
import java.util.ArrayDeque;

import static org.junit.Assert.assertTrue; // import static : une facilité offerte depuis java5 (pas besoin de mettre le préfixe)
import static org.junit.Assert.assertFalse; //
import static org.junit.Assert.assertSame; //
import static org.junit.Assert.assertNotSame; //
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertArrayEquals;
import org.junit.Test;


/**
 * Une classe pour faire des tests sur la classe ShuntingYard avec JUnit
 */
public class TestShuntingYard1 {


    /**
     * ShuntInput déplace un token depuis input vers output
     * 
     */
    @Test
    public void shuntInput(){
	Deque<AbstractToken> expression = new ArrayDeque<AbstractToken>();
	expression.addLast(new TokenConstant(3));
	ShuntingYard se = new ShuntingYard(expression);
	AbstractToken t1 = se.getInput().getFirst();
	se.shuntFromInput();
	AbstractToken t2 = se.getOutput().getLast();
	assertSame(t1,t2);
    }

    /**
     * PushStack déplace un token depuis input vers stack
     * 
     */
    @Test
    public void pushStack(){
	Deque<AbstractToken> expression = new ArrayDeque<AbstractToken>();
	expression.addLast(new TokenConstant(3));
	expression.addLast(new TokenOperator(Operator.ADD));
	expression.addLast(new TokenConstant(4));
	ShuntingYard se = new ShuntingYard(expression);
	se.shuntFromInput();
	AbstractToken t1 = se.getInput().getFirst();
	se.pushToStack();
	AbstractToken t2 = se.getStack().getFirst();
	assertSame(t1,t2);
    }

    /**
     * ShuntFromStack déplace un token depuis stack vers output
     * 
     */
    @Test
    public void shuntStack(){
	Deque<AbstractToken> expression = new ArrayDeque<AbstractToken>();
	expression.addLast(new TokenConstant(3));
	expression.addLast(new TokenOperator(Operator.ADD));
	expression.addLast(new TokenConstant(4));
	ShuntingYard se = new ShuntingYard(expression);
	se.shuntFromInput();
	se.pushToStack();
	se.shuntFromInput();
	AbstractToken t1 = se.getStack().getFirst();
	se.shuntFromStack();
	AbstractToken t2 = se.getOutput().getLast();
	assertSame(t1,t2);
    }

    /**
     * crushParenthesis écrase les parenthèses quand stack est une LB
     * et input est un RB
     */
    @Test
    public void CandyCrush(){
	Deque<AbstractToken> expression = new ArrayDeque<AbstractToken>();
	expression.addLast(new TokenSeparator(Separator.LB));
	expression.addLast(new TokenConstant(2));
	expression.addLast(new TokenOperator(Operator.SUB2));
	expression.addLast(new TokenConstant(1));
	expression.addLast(new TokenSeparator(Separator.RB));
	ShuntingYard se = new ShuntingYard(expression);
	se.pushToStack();
	se.shuntFromInput();
	se.pushToStack();
	se.shuntFromInput();
	se.shuntFromStack();
	//prêt pour enlever les parenthèses.
	AbstractToken t1 = se.getStack().getFirst();
	TokenSeparator s1 = (TokenSeparator) t1;
	int sizeStackbefore = se.getStack().size();
	AbstractToken t2 = se.getInput().getFirst();
	TokenSeparator s2 = (TokenSeparator) t2;
	int sizeInputbefore = se.getInput().size();
	assertEquals(Separator.LB,s1.getSeparator());
	assertEquals(Separator.RB,s2.getSeparator());
	se.crushParenthesis();
	int sizeStackafter = se.getStack().size();
	int sizeInputafter = se.getInput().size();
	assertEquals(sizeStackbefore-1,sizeStackafter);
	assertEquals(sizeInputbefore-1,sizeInputafter);
    }

    /**
     * shunbtingTest1 vérifie que tout se passe bien pour l'exemple de ExempleSY1
     */
    @Test
    public void shuntingTest1(){
	ArrayDeque<AbstractToken> expression = new ArrayDeque<AbstractToken>();
	expression.addLast(new TokenConstant(3));
	expression.addLast(new TokenOperator(Operator.ADD));
	expression.addLast(new TokenConstant(4));
	expression.addLast(new TokenOperator(Operator.MUL));
	expression.addLast(new TokenConstant(2));

	// moralement on veut tester que les trois structures de données sont les mêmes de manière synchrone entre ceci
	// ShuntingYard se1 = new ShuntingYard(expression);
	// se1.shuntFromInput(); //step1
	// se1.pushToStack();    //step2
	// se1.shuntFromInput(); //step3
	// se1.pushToStack();    //step4
	// se1.shuntFromInput(); //step5
	// se1.shuntFromStack(); //step6
	// se1.shuntFromStack(); //step7
	// et cela
	// ShuntingYard se2 = new ShuntingYard(expression);
	// se2.shunting(); //step1
	// Pour tester on utilise la facilité permettant de comparer élément pas élément deux tableaux.
	// assertArrayEquals("Inputs are not the same",se1.getInput().toArray(),se2.getInput().toArray());
	// assertArrayEquals("stacks are not the same",se1.getStack().toArray(),se2.getStack().toArray());
	// assertArrayEquals("Output are not the same",se1.getOutput().toArray(),se2.getOutput().toArray());
	ShuntingYard se1 = new ShuntingYard(expression);
	ShuntingYard se2 = new ShuntingYard(expression.clone());// on clone l'expression, car sinon l'input est le même pour les deux exemples
	assertArrayEquals("Inputs are not the same",se1.getInput().toArray(),se2.getInput().toArray());
	assertArrayEquals("stacks are not the same",se1.getStack().toArray(),se2.getStack().toArray());
	assertArrayEquals("Output are not the same",se1.getOutput().toArray(),se2.getOutput().toArray());
	se1.shuntFromInput(); //step1
	se2.shunting(); //step1
	assertArrayEquals("Inputs are not the same",se1.getInput().toArray(),se2.getInput().toArray());
	assertArrayEquals("stacks are not the same",se1.getStack().toArray(),se2.getStack().toArray());
	assertArrayEquals("Output are not the same",se1.getOutput().toArray(),se2.getOutput().toArray());
	se1.pushToStack();    //step2
	se2.shunting(); //step2
	assertArrayEquals("Inputs are not the same",se1.getInput().toArray(),se2.getInput().toArray());
	assertArrayEquals("stacks are not the same",se1.getStack().toArray(),se2.getStack().toArray());
	assertArrayEquals("Output are not the same",se1.getOutput().toArray(),se2.getOutput().toArray());
	se1.shuntFromInput(); //step3
	se2.shunting(); //step3
	assertArrayEquals("Inputs are not the same",se1.getInput().toArray(),se2.getInput().toArray());
	assertArrayEquals("stacks are not the same",se1.getStack().toArray(),se2.getStack().toArray());
	assertArrayEquals("Output are not the same",se1.getOutput().toArray(),se2.getOutput().toArray());
	se1.pushToStack();    //step4
	se2.shunting(); //step4
	assertArrayEquals("Inputs are not the same",se1.getInput().toArray(),se2.getInput().toArray());
	assertArrayEquals("stacks are not the same",se1.getStack().toArray(),se2.getStack().toArray());
	assertArrayEquals("Output are not the same",se1.getOutput().toArray(),se2.getOutput().toArray());
	se1.shuntFromInput(); //step5
	se2.shunting(); //step5
	assertArrayEquals("Inputs are not the same",se1.getInput().toArray(),se2.getInput().toArray());
	assertArrayEquals("stacks are not the same",se1.getStack().toArray(),se2.getStack().toArray());
	assertArrayEquals("Output are not the same",se1.getOutput().toArray(),se2.getOutput().toArray());
	se1.shuntFromStack(); //step6
	se2.shunting(); //step6
	assertArrayEquals("Inputs are not the same",se1.getInput().toArray(),se2.getInput().toArray());
	assertArrayEquals("stacks are not the same",se1.getStack().toArray(),se2.getStack().toArray());
	assertArrayEquals("Output are not the same",se1.getOutput().toArray(),se2.getOutput().toArray());
	se1.shuntFromStack(); //step7
	se2.shunting(); //step7
	assertArrayEquals("Inputs are not the same",se1.getInput().toArray(),se2.getInput().toArray());
	assertArrayEquals("stacks are not the same",se1.getStack().toArray(),se2.getStack().toArray());
	assertArrayEquals("Output are not the same",se1.getOutput().toArray(),se2.getOutput().toArray());
    }

    

    
}