package oknok.validacao.services;

import com.mongodb.BasicDBObject;
import oknok.utils.Mapper;
import oknok.utils.exceptions.InternalServerErrorException;
import oknok.utils.exceptions.NotFoundException;
import oknok.validacao.daos.*;
import oknok.validacao.entities.Match;
import oknok.validacao.entities.Validacao;
import oknok.validacao.entities.ValidacaoResultado;
import oknok.validacao.readers.planilhas.AtributoReader;
import oknok.validacao.readers.planilhas.PlanilhaReader;
import oknok.validacao.readers.validator.AtributoValidator;
import org.hamcrest.Matchers;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import scala.Enumeration;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;

import static org.assertj.core.api.Assertions.assertThat;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.Matchers.hasProperty;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.argThat;
import static org.mockito.Mockito.*;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = ValidacaoServiceTest.ReaderConfiguration.class)
public class ValidacaoServiceTest {
    @Autowired
    ValidacaoService validacaoService;

    @Autowired
    AtributoValidator atributoValidator;

    @Autowired
    ValidacaoDAO validacaoDAO;

    @Autowired
    UploadDAO uploadDAO;

    @Autowired
    MatchDAO matchDAO;

    @Autowired
    AtributoDAO atributoDAO;

    @Autowired
    ValidacaoResultadoDAO validacaoResultadoDAO;

    @Autowired
    ApplicationContext applicationContext;

    @Autowired
    PlanilhaReader planilhaReader;

    @Autowired
    Mapper mapper;

    @Autowired
    AtributoReader atributoReader;

    private static final ArrayList<String> SWF_FIELDS_FOR_VALIDATION = new ArrayList<String>(Arrays.asList("peca_clicktag", "peca_flash"
            , "peca_tempo", "peca_action-script", "peca_peso", "peca_framerate", "peca_largura", "peca_altura"));


    @Configuration
    static class ReaderConfiguration {
        @Bean
        public ValidacaoService getValidacaoService() {
            return new ValidacaoService();
        }

        @Bean
        public Mapper getMapper() {
            Mapper mock = Mockito.mock(Mapper.class);
            return mock;
        }

        @Bean
        public AtributoReader getAtributoReader() {
            return new AtributoReader();
        }

        @Bean
        public PlanilhaReader getPlanilhaReader() {
            return new PlanilhaReader();
        }

        @Bean
        public MatchDAO getMatchDAO() {
            MatchDAO mock = Mockito.mock(MatchDAO.class);
            return mock;
        }

        @Bean
        public AtributoDAO getAtributoDAO() {
            AtributoDAO mock = Mockito.mock(AtributoDAO.class);
            return mock;
        }

        @Bean
        ValidacaoDAO getValidacaoDAO(){
            Validacao validacao = new Validacao().setId("TESTE").setEmail("ana@sofist.com").setDataCriacao("12/12/08").setDataAtualizacao("12/12/15").setInstancia("T");
            Validacao validacao2 = new Validacao().setId("TESTE02").setEmail("ana02@sofist.com").setDataCriacao("12/12/22").setDataAtualizacao("12/12/22").setInstancia("T");
            Validacao validacao3 = new Validacao().setId("TESTE03").setEmail("ana03@sofist.com").setDataCriacao("12/12/33").setDataAtualizacao("12/12/33").setInstancia("T");
            ValidacaoDAO mock = Mockito.mock(ValidacaoDAO.class);
            List<Validacao> list = new ArrayList<Validacao>();
            list.add(validacao);
            list.add(validacao2);
            list.add(validacao3);
            List<Validacao> emptyList = new ArrayList<Validacao>();
            //Validacao mockSession=Mockito.spy(TestSupport.createSession(sessionID));
            when(mock.findById("id")).thenReturn(new Validacao().setId("123"));
            when(mock.findById("validacaoNotFound")).thenReturn(null);
            when(mock.save(argThat(hasProperty("id",equalTo("TESTE"))))).thenReturn(validacao);
            when(mock.save(argThat(hasProperty("id",equalTo("0000"))))).thenReturn(null);
            when(mock.findAllByInstance("T")).thenReturn(list);
            when(mock.findAllByInstance("Y")).thenReturn(emptyList);
            doNothing().when(mock).remove(any());
            when(mock.update(argThat(hasProperty("id",equalTo("TESTE"))))).thenReturn(validacao);
            when(mock.update(argThat(hasProperty("id",equalTo("0000"))))).thenReturn(null);
            return mock;
        }

        @Bean
        public UploadDAO getUploadDAO() {
            UploadDAO mock = Mockito.mock(UploadDAO.class);
            return mock;
        }

        @Bean
        public ValidacaoResultadoDAO getValidacaoResultadoDAO() {
            ValidacaoResultadoDAO mock = Mockito.mock(ValidacaoResultadoDAO.class);
            return mock;
        }

        @Bean
        public AtributoValidator getAtributoValidator() {
            return new AtributoValidator();
        }
    }





    @Test
    public void validacaoOk(){

        ValidacaoResultado resultadoFinalActual = new ValidacaoResultado();

        List<BasicDBObject> specs  = new ArrayList<>();
        BasicDBObject spec = new BasicDBObject();
        spec.put("spec_extensao" , "swf (gif/jpg)");
        spec.put("peca_clicktag" , "on (release) {\nfscommand (\"URL1\");\n}");
        spec.put("peca_flash" , "8 até 10");
        spec.put("peca_tempo" , "até 30s");
        spec.put("peca_action-script" , "2/3");
        spec.put("peca_peso" , "20kb");
        spec.put("peca_framerate" , "24fps ou superior");
        spec.put("peca_largura" , "300px");
        spec.put("peca_altura" , "250px");

        specs.add(spec);

        BasicDBObject atributos = new BasicDBObject();
        atributos.put("extensao" , "swf (gif/jpg)");
        atributos.put("clicktag" , "on (release) {\nfscommand (\"URL1\");\n}");
        atributos.put("flash" , "9");
        atributos.put("tempo" , "23");
        atributos.put("action-script", "2");
        atributos.put("peso", "20");
        atributos.put("framerate", "24");
        atributos.put("largura" , "300");
        atributos.put("altura" , "250");


        validacaoService.mountResult(resultadoFinalActual, spec, atributos, SWF_FIELDS_FOR_VALIDATION, "OK_NOK");

        ValidacaoResultado resultadoFinalExpected = new ValidacaoResultado();

        BasicDBObject result = new BasicDBObject();
        BasicDBObject map = new BasicDBObject();
        map.append("spec", "on (release) {\nfscommand (\"URL1\");\n}");
        map.append("arquivo", "on (release) {\nfscommand (\"URL1\");\n}");
        map.append("status", "OK");
        result.put("peca_clicktag", map);
        map = new BasicDBObject();
        map.append("spec", "8 até 10");
        map.append("arquivo", "9");
        map.append("status", "OK");
        result.put("peca_flash", map);
        map = new BasicDBObject();
        map.append("spec", "até 30s");
        map.append("arquivo", "23");
        map.append("status", "OK");
        result.put("peca_tempo", map);
        map = new BasicDBObject();
        map.append("spec", "2/3");
        map.append("arquivo", "2");
        map.append("status", "OK");
        result.put("peca_action-script", map);
        map = new BasicDBObject();
        map.append("spec", "20kb");
        map.append("arquivo", "20");
        map.append("status", "OK");
        result.put("peca_peso", map);
        map = new BasicDBObject();
        map.append("spec", "24fps ou superior");
        map.append("arquivo", "24");
        map.append("status", "OK");
        result.put("peca_framerate", map);
        map = new BasicDBObject();
        map.append("spec", "300px");
        map.append("arquivo", "300");
        map.append("status", "OK");
        result.put("peca_largura", map);
        map = new BasicDBObject();
        map.append("spec", "250px");
        map.append("arquivo", "250");
        map.append("status", "OK");
        result.put("peca_altura", map);

        resultadoFinalExpected.setResultado(result);

        Assert.assertEquals(resultadoFinalExpected.getResultado(), resultadoFinalActual.getResultado());
    }

    @Test
    public void validacaoNok(){

        ValidacaoResultado resultadoFinalActual = new ValidacaoResultado();

        List<BasicDBObject> specs  = new ArrayList<>();
        BasicDBObject spec = new BasicDBObject();
        spec.put("spec_extensao" , "swf (gif/jpg)");
        spec.put("peca_clicktag" , "on (release) {\nfscommand (\"URL1\");\n}");
        spec.put("peca_flash" , "8 até 10");
        spec.put("peca_tempo" , "até 20s");
        spec.put("peca_action-script" , "3");
        spec.put("peca_peso" , "10kb");
        spec.put("peca_framerate" , "24fps ou superior");
        spec.put("peca_largura" , "300px");
        spec.put("peca_altura" , "250px");

        specs.add(spec);

        BasicDBObject atributos = new BasicDBObject();
        atributos.put("extensao" , "swf (gif/jpg)");
        atributos.put("clicktag" , "on (release) {\nfscommand (\"URL1\");\n}");
        atributos.put("flash" , "9");
        atributos.put("tempo" , "23");
        atributos.put("action-script", "2");
        atributos.put("peso", "20");
        atributos.put("framerate", "24");
        atributos.put("largura" , "300");
        atributos.put("altura" , "250");


        validacaoService.mountResult(resultadoFinalActual, spec, atributos, SWF_FIELDS_FOR_VALIDATION, "OK_NOK");

        ValidacaoResultado resultadoFinalExpected = new ValidacaoResultado();

        BasicDBObject result = new BasicDBObject();
        BasicDBObject map = new BasicDBObject();
        map.append("spec", "on (release) {\nfscommand (\"URL1\");\n}");
        map.append("arquivo", "on (release) {\nfscommand (\"URL1\");\n}");
        map.append("status", "OK");
        result.put("peca_clicktag", map);
        map = new BasicDBObject();
        map.append("spec", "8 até 10");
        map.append("arquivo", "9");
        map.append("status", "OK");
        result.put("peca_flash", map);
        map = new BasicDBObject();
        map.append("spec", "até 20s");
        map.append("arquivo", "23");
        map.append("status", "NOK");
        result.put("peca_tempo", map);
        map = new BasicDBObject();
        map.append("spec", "3");
        map.append("arquivo", "2");
        map.append("status", "NOK");
        result.put("peca_action-script", map);
        map = new BasicDBObject();
        map.append("spec", "10kb");
        map.append("arquivo", "20");
        map.append("status", "NOK");
        result.put("peca_peso", map);
        map = new BasicDBObject();
        map.append("spec", "24fps ou superior");
        map.append("arquivo", "24");
        map.append("status", "OK");
        result.put("peca_framerate", map);
        map = new BasicDBObject();
        map.append("spec", "300px");
        map.append("arquivo", "300");
        map.append("status", "OK");
        result.put("peca_largura", map);
        map = new BasicDBObject();
        map.append("spec", "250px");
        map.append("arquivo", "250");
        map.append("status", "OK");
        result.put("peca_altura", map);

        resultadoFinalExpected.setResultado(result);

        Assert.assertEquals(resultadoFinalExpected.getResultado(), resultadoFinalActual.getResultado());
    }

    @Test
    public void testRetrieve_withValidId_shouldReturnSuccess() {
        Validacao validacao = validacaoService.retrieve("id");
        String expected = "123";
        assertThat(validacao.getId()).isEqualTo(expected);
    }

    @Test(expected = NotFoundException.class)
    public void testRetrieve_withInvalidId_shouldThrowException() {
        Validacao validacao = validacaoService.retrieve("validacaoNotFound");
    }

    @Test
    public void testCreate_withValidValidacao_shouldReturnValidacao() {

        Validacao validacao = new Validacao();
        validacao.setId("TESTE");
        validacao.setEmail("ana@sofist.com");
        validacao.setDataCriacao("12/12/08");
        validacao.setDataAtualizacao("12/12/15");
        validacao.setInstancia("T");

        Validacao retorno = validacaoService.create(validacao);
        assertThat(retorno).isEqualToComparingFieldByField(validacao); //assert que diz em QUAL campo esta o problema

    }

    @Test (expected = InternalServerErrorException.class)
    public void testCreate_withInvalidValidacao_shouldThrowException() {

        Validacao validacao = new Validacao();
        validacao.setId("0000");
        validacaoService.create(validacao);

    }

    @Test
    public void testRetrieveAll_withValidInstance_shouldReturnList() {

        List<Validacao> retorno = validacaoService.retrieveAll("T");
        assertThat(retorno.size()).isEqualTo(3);
    }

    @Test
    public void testRetrieveAll_withInvalidInstance_shouldReturnEmptyList() {
        assertThat(validacaoService.retrieveAll("Y")).isEmpty();
    }

    @Test(expected = NotFoundException.class)
    public void testRemove_withInvalidId_shouldThrowException() {
        validacaoService.remove("validacaoNotFound");
    }

    @Test
    public void testRemove_withValidId_shouldCallRemove() {
        validacaoService.remove("id");
        verify(validacaoDAO,times(1)).remove("id");
    }

    @Test
    public void testUpdate_withValidValidacao_shouldReturnUpdatedValidacao() {

        Date data = new Date();
        Validacao validacao = new Validacao();
        validacao.setId("TESTE");
        validacao.setEmail("ana@sofist.com");
        validacao.setDataCriacao("12/12/08");
        validacao.setDataAtualizacao("12/12/15");
        validacao.setInstancia("T");

        Validacao retorno = validacaoService.update(validacao);
        Date dataNova = new Date();
        assertThat(new Date(retorno.getDataAtualizacao())).isBefore(dataNova); //esta dando erro
        assertThat(retorno).isEqualToIgnoringGivenFields(validacao, "dataAtualizacao");
        assertThat(new Date(retorno.getDataAtualizacao())).isAfter(data);
        verify(validacaoDAO, times(1)).update(validacao);

    }

    @Test (expected = NotFoundException.class)
    public void testUpdate_withInvalidValidacao_shouldThrowException() {
        validacaoService.update(new Validacao().setId("0000"));
    }
}