package de.superx.rest.kenn;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThrows;
import static org.junit.Assert.assertTrue;

import java.io.File;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.junit.Before;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.io.FileSystemResource;
import org.springframework.jdbc.datasource.init.ScriptException;
import org.springframework.jdbc.datasource.init.ScriptUtils;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.transaction.annotation.Transactional;

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.json.JsonMapper;

import de.superx.BaseDbTest;
import de.superx.TestApplicationConfigPg;
import de.superx.common.AccessDeniedException;
import de.superx.common.SxUser;
import de.superx.jdbc.entity.kenn.Stichtag;
import de.superx.jdbc.entity.kennx.Lieferfreigabe;
import de.superx.jdbc.entity.kennx.LieferfreigabeHs;
import de.superx.jdbc.entity.kennx.LieferfreigabeStichtagsart;
import de.superx.jdbc.entity.kennx.LieferfreigabeStichtagsartBezugszeit;
import de.superx.rest.InputValidationError;
import de.superx.rest.KennConfigApi;
import de.superx.spring.TestUserServiceImpl;
import de.superx.spring.service.UserService;


@Transactional
public class KennConfigApiTest extends BaseDbTest {

    
    static String RW_TEST_PATH = String.join(File.separator, new String[] {"test", "resources", "db", "fixtures", "kennx" }); 
    private static final String RIGHT_ADMIN = "RIGHT_CS_BIA_STANDARDREPORTS_ADMIN";
    private static final String RIGHT_REPORT_DELIVERY = "RIGHT_CS_BIA_STANDARDREPORTS_MANAGE_REPORTDELIVERY";
    private static final String CREATE_KENNX_TABLES = String.join(File.separator, new String[] {"test", "resources", "db", "fixtures", "kennx", "create_kennx_tables.sql" }); 
    
    @Autowired
    private KennConfigApi kennConfigApi;
    
    @Before
    public void init() throws ScriptException, SQLException {
        try (Connection con = dataSource.getConnection()) {
            ScriptUtils.executeSqlScript(con, new FileSystemResource(new File(CREATE_KENNX_TABLES)));
        }
    }

 
    @Test
    public void testSaveLieferfreigabe() {
        String file = "lieferfreigabe";
        saveLieferfreigabeFromFile(file);
    }
    
    @Test
    public void testSaveLieferfreigabeManyStichtagsarten() {
        String file = "lieferfreigabeHochschulerfolgsbericht";
        saveLieferfreigabeFromFile(file);
    }
     
    @Test
    public void testSaveLieferfreigabeDateFrom() {
        String file = "lieferfreigabeDateFrom";
        saveLieferfreigabeFromFile(file);
    }
     
    @Test
    public void testSaveLieferfreigabeDateTo() {
        String file = "lieferfreigabeDateTo";
        saveLieferfreigabeFromFile(file);
    }
     
    @Test
    public void testSaveLieferfreigabePeriod() {
        String file = "lieferfreigabePeriod";
        saveLieferfreigabeFromFile(file);
    }
          
    @Test
    public void testSaveLieferfreigabeFilter() {
        String file = "lieferfreigabeDateTo";
        saveLieferfreigabeFromFile(file);
    }
     
    @Test
    public void testSaveAndDeleteLieferfreigabe() {
        String file = "lieferfreigabe";
        saveLieferfreigabeFromFile(file);
        int[] ids = {1};
        kennConfigApi.deleteLieferfreigaben(ids);
        assertEquals(0, kennConfigApi.getLieferfreigabenConfig().size());
    }
    
    @Test 
    public void deleteNotExistingLieferfreigabe() {
        String file = "lieferfreigabe";
        saveLieferfreigabeFromFile(file);
        int[] ids = {2,3,4};
        kennConfigApi.deleteLieferfreigaben(ids);
        assertEquals(1, kennConfigApi.getLieferfreigabenConfig().size());
    }
     
    @Test
    public void testSaveLieferfreigabeWithAdminRights() {
        setAdminRights();
        String file = "lieferfreigabeHochschulerfolgsbericht";
        Lieferfreigabe lieferfreigabe = readLieferfreigabeFromJson(file);
        //adminrights are not enough a special right is needed
        assertThrows(AccessDeniedException.class, () -> {
            kennConfigApi.saveLieferfreigabe(lieferfreigabe);
        });
    }
     
    @Test
    public void testDeleteLieferfreigabeWithAdminRights() {
       setAdminRights();
       //adminrights are not enough a special right is needed
       assertThrows(AccessDeniedException.class, () -> {
           int[] ids = {1};
           kennConfigApi.deleteLieferfreigaben(ids);
       });
    }
    
    @Test
    public void testSaveLieferfreigabePreventOverwrite() {
        setReportDeliveryRights();
        saveInvalidLieferfreigabe("lieferfreigabeWithTid");
    }
     
    @Test
    public void testSaveLieferfreigabeInvalidPeriod() {
        setReportDeliveryRights();
        saveInvalidLieferfreigabe("lieferfreigabeInvalidPeriod");
    }
     
    @Test
    public void testSaveLieferfreigabeInvalidBezugszeit() {
        setReportDeliveryRights();
        saveInvalidLieferfreigabe("lieferfreigabeInvalidBezugszeit");
    }
     
   
    @Test
    public void testSaveLieferfreigabeInvalidFilter() {
        setReportDeliveryRights();
        saveInvalidLieferfreigabe("lieferfreigabeInvalidFilter");
    }

    @Test
    public void testSaveStichtage() {
        setAdminRights();
        List<Stichtag> stichtage = readStichtageFromJson("stichtage");
        kennConfigApi.saveStichtageConfig(stichtage);
        compareStichtage(stichtage, kennConfigApi.getStichtageConfig());
    }
    
    @Test
    public void testSaveStichtageWithoutDuplicates() {
        setAdminRights();
        List<Stichtag> stichtage = readStichtageFromJson("stichtage");
        List<Stichtag> stichtage2 = readStichtageFromJson("stichtage");
        kennConfigApi.saveStichtageConfig(stichtage);
        int numberOfStichtage = kennConfigApi.getStichtageConfig().size();
        kennConfigApi.saveStichtageConfig(stichtage2);
        assertEquals(numberOfStichtage, kennConfigApi.getStichtageConfig().size());
        compareStichtage(stichtage, kennConfigApi.getStichtageConfig());
    }
    
    @Test
    public void testSaveAndDeleteStichtage() {
        setAdminRights();
        List<Stichtag> stichtage = readStichtageFromJson("stichtag");
        kennConfigApi.saveStichtageConfig(stichtage);
        int[] ids = {1};
        kennConfigApi.deleteStichtage(ids);
        assertEquals(0, kennConfigApi.getStichtageConfig().size());
    }
    
    
    @Test
    public void testSaveStichtagPreventOverwrite() {
        setAdminRights();
        List<Stichtag> stichtage = readStichtageFromJson("stichtageWithTid");
        assertThrows(InputValidationError.class, () -> {
            kennConfigApi.saveStichtageConfig(stichtage);
        });    
    } 
    
    @Test
    public void testSaveStichtageInvalidBezugsart() {
        setAdminRights();
        List<Stichtag> stichtage = readStichtageFromJson("stichtageInvalidBezugsart");
        assertThrows(InputValidationError.class, () -> {
            kennConfigApi.saveStichtageConfig(stichtage);
        });
    }
    
    @Test
    public void testSaveStichtageInvalidBezugszeit() {
        setAdminRights();
        List<Stichtag> stichtage = readStichtageFromJson("stichtageInvalidBezugszeit");
        assertThrows(InputValidationError.class, () -> {
            kennConfigApi.saveStichtageConfig(stichtage);
        });
    }
    
    @Test
    public void testSaveStichtageInvalidStichtagsart() {
        setAdminRights();
        List<Stichtag> stichtage = readStichtageFromJson("stichtageInvalidStichtagsart");
        assertThrows(InputValidationError.class, () -> {
            kennConfigApi.saveStichtageConfig(stichtage);
        });
    }
    
    @Test
    public void testSaveStichtagMissingDate() {
        setAdminRights();
        List<Stichtag> stichtage = readStichtageFromJson("stichtageMissingDate");
        assertThrows(InputValidationError.class, () -> {
            kennConfigApi.saveStichtageConfig(stichtage);
        });    
    }
    
    
    
    @Test
    public void testSaveStichtageNoRights() {
       setNoneRights();
       assertThrows(AccessDeniedException.class, () -> {
           List<Stichtag> stichtage = readStichtageFromJson("stichtage");
           kennConfigApi.saveStichtageConfig(stichtage);
       });
    }
    
    @Test
    public void testDeleteStichtageNoRights() {
       setNoneRights();
       assertThrows(AccessDeniedException.class, () -> {
           int[] ids = {1};
           kennConfigApi.deleteStichtage(ids);
       });
    }


    public void saveInvalidLieferfreigabe(String file) {
        Lieferfreigabe lieferfreigabe = readLieferfreigabeFromJson(file);
        assertThrows(InputValidationError.class, () -> {
            kennConfigApi.saveLieferfreigabe(lieferfreigabe);
        });
    }
     
    private void saveLieferfreigabeFromFile(String file) {
        setReportDeliveryRights();
        Lieferfreigabe lieferfreigabe = readLieferfreigabeFromJson(file);
        List<Lieferfreigabe> freigaben = kennConfigApi.getLieferfreigabenConfig();
        kennConfigApi.saveLieferfreigabe(lieferfreigabe);
        freigaben = kennConfigApi.getLieferfreigabenConfig();
        Lieferfreigabe lieferfreigabe2 = freigaben.get(0);
        compareLieferfreigabe(lieferfreigabe, lieferfreigabe2);
    }

    private static Lieferfreigabe readLieferfreigabeFromJson(String name) {
        String path = String.join(File.separator, new String[] {RW_TEST_PATH, "req", name + ".json"});
        ObjectMapper mapper = JsonMapper.builder().findAndAddModules().build();
        Lieferfreigabe lieferfreigabe = null;
        File test = new File (path); 
        try {
            lieferfreigabe = mapper.readValue(test, Lieferfreigabe.class);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return lieferfreigabe;
    }
    
    private static List<Stichtag> readStichtageFromJson(String name) {
        String path = String.join(File.separator, new String[] {RW_TEST_PATH, "req", name + ".json"});
        ObjectMapper mapper = JsonMapper.builder().findAndAddModules().build();
        List<Stichtag> stichtage = null;
        File test = new File (path); 
        try {
            stichtage = mapper.readValue(test, new TypeReference<List<Stichtag>>(){});
        } catch (Exception e) {
            e.printStackTrace();
        }
        return stichtage;
    }
    
    /*
     * Ein direkter Vergleich der einzelnen Objekte ist nicht möglich, da einige IDs von Objekten
     * erst beim Speichern gesetzt werden.
     * Zudem unterschieden sich die gespeicherten Strings von denen, die aus der Datenbank geholt werden durch 
     * trailing space. Dies wird hoffentlich nach und nach noch in der Datenbank angepasst.
     * Die Anpassung von equals() in den einzelnen Objekten würde auch die Anpassung von hashcode() erfordern
     * um Vergleichsfunktionen wie containsAll() für Sets zu nutzen.
     * Der Vorteil dieser umfangreichen Funktion ist, dass eine Fehlerursache innerhalb eines Objektes direkt
     * erkannt werden kann.
     * Nachteil ist, dass die Reihenfolge der Hochschulen, Stichtagsarten und Bezugszeiten der 
     * zu vergleichenden Lieferfreigaben identisch sein müssen.
    */
    private static void compareLieferfreigabe(Lieferfreigabe lieferfreigabe1, Lieferfreigabe lieferfreigabe2) {
        assertEquals(lieferfreigabe1.report_name, lieferfreigabe2.report_name);
        assertEquals(lieferfreigabe1.additional_filter_name, lieferfreigabe2.additional_filter_name);
        assertEquals(lieferfreigabe1.gueltig_bis, lieferfreigabe2.gueltig_bis);
        assertEquals(lieferfreigabe1.gueltig_von, lieferfreigabe2.gueltig_von);
        assertEquals(lieferfreigabe1.lieferfreigabeHs.size(), lieferfreigabe2.lieferfreigabeHs.size());
        assertEquals(lieferfreigabe1.lieferfreigabeStichtagsart.size(), lieferfreigabe2.lieferfreigabeStichtagsart.size());
        
        Iterator<LieferfreigabeHs> hsItr1 = lieferfreigabe1.lieferfreigabeHs.iterator();
        Iterator<LieferfreigabeHs> hsItr2 = lieferfreigabe2.lieferfreigabeHs.iterator();
        while(hsItr1.hasNext() && hsItr2.hasNext()){
            LieferfreigabeHs hochschule1 = hsItr1.next();
            LieferfreigabeHs hochschule2 = hsItr2.next();
            assertEquals(hochschule1.hochschule_name.trim(), hochschule2.hochschule_name.trim());
            assertEquals(hochschule1.hsNr, hochschule2.hsNr);
        }
        
        Iterator<LieferfreigabeStichtagsart> sItr1 = lieferfreigabe1.lieferfreigabeStichtagsart.iterator();
        Iterator<LieferfreigabeStichtagsart> sItr2 = lieferfreigabe2.lieferfreigabeStichtagsart.iterator();
        while(sItr1.hasNext() && sItr2.hasNext()){
            LieferfreigabeStichtagsart stichtagsart1 = sItr1.next();
            LieferfreigabeStichtagsart stichtagsart2 = sItr2.next();
            assertEquals(stichtagsart1.datum_wird_ausgewertet, stichtagsart2.datum_wird_ausgewertet);
            assertEquals(stichtagsart1.kennxLieferfreigabeStichtagsartBezugszeit.size(), stichtagsart2.kennxLieferfreigabeStichtagsartBezugszeit.size());
            assertEquals(stichtagsart1.stichtagsart_name, stichtagsart2.stichtagsart_name);
            assertEquals(stichtagsart1.stichtagsartId, stichtagsart2.stichtagsartId.trim());
            Iterator<LieferfreigabeStichtagsartBezugszeit> bItr1 = stichtagsart1.kennxLieferfreigabeStichtagsartBezugszeit.iterator();
            Iterator<LieferfreigabeStichtagsartBezugszeit> bItr2 = stichtagsart2.kennxLieferfreigabeStichtagsartBezugszeit.iterator();
            while(bItr1.hasNext()) {
                LieferfreigabeStichtagsartBezugszeit bezugszeit1 = bItr1.next();
                LieferfreigabeStichtagsartBezugszeit bezugszeit2 = bItr2.next();
                assertEquals(bezugszeit1.bezugsartId, bezugszeit2.bezugsartId);
                assertEquals(bezugszeit1.value, bezugszeit2.value);
            }
        }
    }
    
    /* 
     * Das equals() von Stichtage wurde überschrieben, sodass trailing space nicht entscheidend für unterschiedliche 
     * Objekte sind. 
    */
    private static void compareStichtage(List<Stichtag> stichtage1, List<Stichtag> stichtage2) {
        assertEquals(stichtage1.size(), stichtage2.size());
        assertTrue(stichtage1.containsAll(stichtage2));
        assertTrue(stichtage2.containsAll(stichtage1));
    }
    
    
    private void setAdminRights() {
        Map<String, Map<String,String>> rightsMap = new HashMap<>();
        rightsMap.put(RIGHT_ADMIN, null);
        user.setRights(rightsMap, null);
    }
    
    private void setReportDeliveryRights() {
        Map<String, Map<String,String>> rightsMap = new HashMap<>();
        rightsMap.put(RIGHT_REPORT_DELIVERY, null);
        user.setRights(rightsMap, null);
    }
    
    private void setNoneRights() {
        Map<String, Map<String,String>> rightsMap = new HashMap<>();
        user.setRights(rightsMap, null);
    }
    
}