import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;

import java.util.ArrayList;
import java.util.List;

public class ChainblockImplTest {
    private Chainblock database; //база от данни с транзакции

    @Before
    public void setUp() {
        this.database = new ChainblockImpl(); //празна база от данни с транзакции
    }

    //add
    //1. добавяме транзакция, която я няма
    @Test
    public void testAddTransaction () {
        Assert.assertEquals(0, this.database.getCount());
        //0 транзакции
        Transaction transaction1 = new TransactionImpl(1, TransactionStatus.SUCCESSFUL, "Desi", "Stoyan", 150.90);
        //добавяме транзакция
        this.database.add(transaction1);
        //1 транзакция
        Assert.assertEquals(1, this.database.getCount());
        Assert.assertTrue(this.database.contains(transaction1)); //проверка за наличие по transaction
    }

    //2. добавяме транзакция, която я има
    @Test
    public void testAddExistingTransaction () {
        Assert.assertEquals(0, this.database.getCount());
        //0 транзакции
        Transaction transaction1 = new TransactionImpl(1, TransactionStatus.SUCCESSFUL, "Desi", "Stoyan", 150.90);
        this.database.add(transaction1);
        //1 транзакция
        Assert.assertEquals(1, this.database.getCount());
        Assert.assertTrue(this.database.contains(transaction1.getId())); //проверка за наличие по id
        //добавяме същата транзакция / добавяме вече съществуваща транзакция
        this.database.add(transaction1);
        //1 транзакция
        Assert.assertEquals(1, this.database.getCount());
    }

    /*@Test
    public void testAdd () {
        Assert.assertEquals("Initial database is not empty.", 0, this.database.getCount());
        //0 транзакции
        Transaction transaction1 = new TransactionImpl(1, TransactionStatus.SUCCESSFUL, "Desi", "Stoyan", 150.90);
        //добавяме транзакция
        this.database.add(transaction1);
        //1 транзакция
        Assert.assertEquals("Error in add transaction.",1, this.database.getCount());
        Assert.assertTrue("Transaction does not exist in database.", this.database.contains(transaction1));
        //добавяме същата транзакция / добавяме вече съществуваща транзакция
        this.database.add(transaction1);
        //1 транзакция
        Assert.assertEquals("Duplicate transactions.",1, this.database.getCount());
    }*/

    //changeTransactionStatus
    //1. намираме транзакция с даденото id -> сменям статуса и със дадения
    @Test
    public void testChangeTransactionStatus () {
        Assert.assertEquals(0, this.database.getCount()); //{}
        Transaction transaction1 = new TransactionImpl(1, TransactionStatus.SUCCESSFUL, "Desi", "Stoyan", 150.90); //първоначално добавената
        this.database.add(transaction1); // {tr1}
        Assert.assertEquals(1, this.database.getCount());
        this.database.changeTransactionStatus(1, TransactionStatus.ABORTED);
        Assert.assertEquals(TransactionStatus.ABORTED, this.database.getById(1).getStatus());
    }

    //2. не намираме транзакция с даденото id -> очакваме IllegalArgumentException
    @Test(expected = IllegalArgumentException.class)
    public void testChangeTransactionStatusInvalidId() {
        Assert.assertEquals(0, this.database.getCount()); //{}
        Transaction transaction1 = new TransactionImpl(1, TransactionStatus.SUCCESSFUL, "Desi", "Stoyan", 150.90); //първоначално добавената
        this.database.add(transaction1); // {tr1}
        this.database.changeTransactionStatus(2, TransactionStatus.ABORTED);
    }

    //removeTransactionById
    //1. намираме транзакция с даденото id -> премахваме транзакцията
    @Test
    public void testRemoveTransactionById () {
        //0 transactions
        Assert.assertEquals(0, this.database.getCount()); //{}
        Transaction transaction1 = new TransactionImpl(1, TransactionStatus.SUCCESSFUL, "Desi", "Stoyan", 150.90);
        Transaction transaction2 = new TransactionImpl(2, TransactionStatus.ABORTED, "Ivan", "Dimitar", 200.50);
        this.database.add(transaction1);
        this.database.add(transaction2);
        //2 transactions
        Assert.assertEquals(2, this.database.getCount()); //{transaction1, transaction2}
        //премахнва транзакция с id = 1
        this.database.removeTransactionById(1);
        //1 transaction
        Assert.assertEquals(1, this.database.getCount()); //{transaction2}
        Assert.assertFalse(this.database.contains(1));
    }


    //2. не намираме транзакция с даденото id -> очакваме IllegalArgumentException
    @Test(expected = IllegalArgumentException.class)
    public void testRemoveInvalidTransactionById() {
        //0 transactions
        Assert.assertEquals(0, this.database.getCount()); //{}
        Transaction transaction1 = new TransactionImpl(1, TransactionStatus.SUCCESSFUL, "Desi", "Stoyan", 150.90);
        this.database.add(transaction1);
        //1 transaction -> {id: 1, TransactionStatus.SUCCESSFUL, from: "Desi", to: "Stoyan", amount: 150.90}
        this.database.removeTransactionById(5);
    }

    //getById
    //1. ако съществува транзакция с даденото id -> връщаме транзакцията с това id
    @Test
    public void testGetTransactionById() {
        //0 transactions
        Assert.assertEquals(0, this.database.getCount()); //{}
        Transaction transaction1 = new TransactionImpl(1, TransactionStatus.SUCCESSFUL, "Desi", "Stoyan", 150.90);
        this.database.add(transaction1); //{tr1}
        Transaction returnedTransaction = this.database.getById(1);
        //начин 1:
        // проверка дали върнатаа транзакция е същата като добавената транзакция с id = 1
        Assert.assertEquals(transaction1, returnedTransaction);
        //начин 2: стойността на всяко поле
        Assert.assertEquals("Id is not correct.", transaction1.getId(), returnedTransaction.getId());
        Assert.assertEquals("Status is not correct.", transaction1.getStatus(), returnedTransaction.getStatus());
    }

    //2. ако не съществува транзакция с даденото id -> очакваме IllegalArgumentException
    @Test(expected = IllegalArgumentException.class)
    public void testGetTransactionByInvalidId() {
        Transaction transaction1 = new TransactionImpl(1, TransactionStatus.SUCCESSFUL, "Desi", "Stoyan", 150.90);
        this.database.add(transaction1); //1 транзакция -> {1, TransactionStatus.SUCCESSFUL, "Desi", "Stoyan", 150.90}
        this.database.getById(5);
    }

    //getByTransactionStatus
    //1. валиден статус -> всички транзакции с този статус, подредени по descending (от най-голямото към най-малкото) по amount
    @Test
    public void testGetTransactionsByStatus() {
        //0 transactions
        Assert.assertEquals(0, this.database.getCount()); //{}
        Transaction transaction1 = new TransactionImpl(1, TransactionStatus.SUCCESSFUL, "Desi", "Stoyan", 50.00);
        Transaction transaction2 = new TransactionImpl(2, TransactionStatus.SUCCESSFUL, "Desi", "Ivan", 120.00);
        Transaction transaction3 = new TransactionImpl(3, TransactionStatus.ABORTED, "Desi", "Peter", 90.00);
        this.database.add(transaction1);
        this.database.add(transaction2);
        this.database.add(transaction3);
        Assert.assertEquals(3, this.database.getCount()); //{transaction1, transaction2, transaction3}

        Iterable<Transaction> result = this.database.getByTransactionStatus(TransactionStatus.SUCCESSFUL);
        List<Transaction> returnedTransactions = new ArrayList<>(); //всички транзакции със статус SUCCESSFUL -> {transaction2, transaction1}
        result.forEach(returnedTransactions::add);

        //верен ли е броят на върнатите транзакции?
        Assert.assertEquals(2, returnedTransactions.size());
        //всички върнати транзакции са със статус SUCCESSFUL
        returnedTransactions.forEach(tr -> Assert.assertEquals(TransactionStatus.SUCCESSFUL, tr.getStatus()));
        //върнатите транзакции са правилно подредени -> {}
        Assert.assertEquals(returnedTransactions.get(0), transaction2);
        Assert.assertEquals(returnedTransactions.get(1), transaction1);

    }
    //2. липсваща транзакция с дадения статус -> очакваме IllegalArgumentException
    @Test(expected = IllegalArgumentException.class)
    public void testGetByMissingTransactionStatus() {
        //0 transactions
        Assert.assertEquals(0, this.database.getCount()); //{}
        Transaction transaction1 = new TransactionImpl(1, TransactionStatus.SUCCESSFUL, "Desi", "Stoyan", 50.00);
        Transaction transaction2 = new TransactionImpl(2, TransactionStatus.SUCCESSFUL, "Desi", "Ivan", 120.00);
        Transaction transaction3 = new TransactionImpl(3, TransactionStatus.ABORTED, "Desi", "Peter", 90.00);
        this.database.add(transaction1);
        this.database.add(transaction2);
        this.database.add(transaction3);
        Assert.assertEquals(3, this.database.getCount()); //{transaction1, transaction2, transaction3}

        Iterable<Transaction> result = this.database.getByTransactionStatus(TransactionStatus.FAILED);
    }
}