package de.superx.spring.batch;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;

import java.io.File;
import java.io.IOException;
import java.io.StringReader;
import java.io.StringWriter;
import java.util.List;

import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;

import org.junit.Before;
import org.junit.Test;
import org.springframework.batch.core.Job;
import org.springframework.batch.core.job.flow.FlowJob;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.datasource.init.ScriptException;
import org.w3c.dom.Document;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;

import de.superx.BaseDbTest;
import de.superx.dbt.UnsupportedPythonVersionException;
import de.superx.job.ContainerNode;
import de.superx.servlet.SuperXManager;
import de.superx.spring.batch.tasklet.TaskletContext;
import de.superx.spring.batch.util.StepCounter;
import de.superx.spring.service.BatchJobDescriptionAdapter;
import de.superx.spring.service.DbJobDescriptionAdapter;
import de.superx.spring.service.EntityJobDescriptionSource;
import de.superx.spring.service.JobDescriptionSource;
import de.superx.util.PathAndFileUtils;

public class EntityJobDescriptionSourceTest  extends BaseDbTest {
    
    @Autowired
    DbJobDescriptionAdapter dbAdapter;
    
    @Autowired
    BatchJobDescriptionAdapter batchJobDecriptionAdapter;
    
    @Autowired
    JobDescriptionSource entityJobDescriptionSource;
    
	private final DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory
						.newInstance();

	@Before
	public void init() {
        File webInfPath = new File(String.join(File.separator, "superx", "WEB-INF"));
        SuperXManager.setWEB_INFPfad(webInfPath.getAbsolutePath());
	}
	
    @Test
    public void test() throws ScriptException {
       ContainerNode root = entityJobDescriptionSource.getLoadAndTransformJob("sos"); 
       assertNotNull("Root node not empty", root);
    }

    @Test
    public void testEtlSteps() {
        ContainerNode root = entityJobDescriptionSource.getLoadAndTransformJob("sos"); 
        assertEquals("Root node has etl-step children", 5, root.size());
    }
    
    @Test
    public void testUnloadSteps() {
        ContainerNode root = entityJobDescriptionSource.getUnloadJob("sos"); 
        assertNotNull("Root node not empty", root);
    }
    
    @Test
    public void testInstallSteps() {
    	ContainerNode root = entityJobDescriptionSource.getInstallUpgradeJob("cob");
    	assertNotNull("Root node not empty", root);
    }
    
    @Test
    public void writeToDb() throws ScriptException {
        ContainerNode root = entityJobDescriptionSource.getLoadAndTransformJob("sos"); 
        dbAdapter.writeToDb(root);
    }
    
    @Test
    public void writeInstallToDb() {
    	ContainerNode root = entityJobDescriptionSource.getInstallUpgradeJob("cob");
    	dbAdapter.writeToDb(root);
    }
    
//    @Test
    public void writeUnloadToDb() throws ScriptException {
        ContainerNode root = entityJobDescriptionSource.getUnloadJob("sos"); 
        dbAdapter.writeToDb(root);
    }
    
    @Test
    public void transformXmlToJob() throws ScriptException, UnsupportedPythonVersionException {
        ContainerNode root = entityJobDescriptionSource.getLoadAndTransformJob("sos"); 
        Job job = batchJobDecriptionAdapter.transformToBatchJob(root, "hisinone", new StepCounter(), null, new TaskletContext());
        assertNotNull("Job not empty", job);
        assertTrue("Job contains steps", ((FlowJob) job).getStepNames().size() > 0);
    }
    
    @Test
    public void transformXmlToUnloadJob() throws UnsupportedPythonVersionException {
        ContainerNode root = entityJobDescriptionSource.getUnloadJob("sos"); 
        Job job = batchJobDecriptionAdapter.transformToBatchJob(root, "hisinone", new StepCounter(), null, new TaskletContext());
        assertNotNull("Job not empty", job);
        assertTrue("Job contains steps", ((FlowJob) job).getStepNames().size() > 0);
    }
    
    @Test
    public void transformDbToJob() throws ScriptException, UnsupportedPythonVersionException {
        ContainerNode root = entityJobDescriptionSource.getLoadAndTransformJob("sos"); 
        dbAdapter.writeToDb(root);
        ContainerNode rootFromDb = dbAdapter.getJobById("sos_load_and_transform"); 
        assertNotNull("Job not empty", rootFromDb);
        Job job = batchJobDecriptionAdapter.transformToBatchJob(rootFromDb, "hisinone", new StepCounter(), null, new TaskletContext());
        assertNotNull("Batch job not empty", job);
        assertTrue("Job contains steps", ((FlowJob) job).getStepNames().size() > 1);
        
    }

    @Test
    public void transformDbToUnloadJob() throws ScriptException, UnsupportedPythonVersionException {
        ContainerNode root = entityJobDescriptionSource.getUnloadJob("sos"); 
        dbAdapter.writeToDb(root);
        ContainerNode rootFromDb = dbAdapter.getJobById("sos_unload"); 
        assertNotNull("Job not empty", rootFromDb);
        Job job = batchJobDecriptionAdapter.transformToBatchJob(rootFromDb, "hisinone", new StepCounter(), null, new TaskletContext());
        assertNotNull("Batch job not empty", job);
        assertTrue("Job contains steps", ((FlowJob) job).getStepNames().size() > 1);
        
    }
    
    @Test
    public void writeAllToDb() throws ScriptException {
        List<String> modules = List.of("kern", "zul", "cob", "fin", "ivs", "sva", "bau", "prom", "res");
        for (String module : modules) {
            ContainerNode root = entityJobDescriptionSource.getLoadAndTransformJob(module); 
            dbAdapter.writeToDb(root);
            ContainerNode rootUnl = entityJobDescriptionSource.getUnloadJob(module); 
            dbAdapter.writeToDb(rootUnl);
        }
    }
    
    @Test
    public void overwriteNonCustomJob() throws ScriptException {
        ContainerNode root = entityJobDescriptionSource.getLoadAndTransformJob("sos"); 
        int jobTidOrig = dbAdapter.writeToDb(root);
        int jobTidNew = dbAdapter.writeToDb(root);
        ContainerNode rootUnl = entityJobDescriptionSource.getUnloadJob("sos"); 
        int jobUnlTidOrig = dbAdapter.writeToDb(rootUnl);
        int jobUnlTidNew = dbAdapter.writeToDb(rootUnl);
        assertTrue("Old and new job tid not equal", jobTidOrig != jobTidNew);
        assertTrue("Old and new etl job tid not equal", jobUnlTidOrig != jobUnlTidNew);
    }
    
    @Test
    public void getEtlStepByExistingId() throws ScriptException {
        String id = "sos_stu_realtime_unload_special";
        ContainerNode root = entityJobDescriptionSource.getJobById(id);
        assertNotNull("Root node is not null", root);
        assertTrue("Container has children", root.size() > 0);
    }
    
    @Test
    public void getEtlStepByNonExistingId() throws ScriptException {
        ContainerNode root = entityJobDescriptionSource.getJobById("foobar");
        assertTrue("Root node is null", root == null);
    }

    @Test 
    public void getAllManualEtlSteps() throws ScriptException {
        List<ContainerNode> manualEtlSteps = entityJobDescriptionSource.getSpecialJobs("sos");
        assertEquals("Manual etl step count for sos", 8, manualEtlSteps.size());
    }
    
    @Test
    public void readXmlFromDbi() {
        String id = "load_student_weighting";
        String name = "Erweiterte Studierendengewichtung Regeln laden";
        File dbiFile = PathAndFileUtils.getDbiFileForManualEtlStep("sos", id, "pg");
        File xslFile = PathAndFileUtils.getXslFile("dbi_ulr.xsl");
        Source xslSource = new StreamSource(xslFile);
        StringWriter writer = new StringWriter();
        Transformer transformer;
        String result = null;
        List<ContainerNode> nodes = null;
        try {
            transformer = TransformerFactory.newDefaultInstance().newTransformer(xslSource);
            transformer.setParameter("id", id);
            transformer.setParameter("name", name);
            transformer.setParameter("systemInfoId", Integer.valueOf(130));
            transformer.transform(new StreamSource(dbiFile), new StreamResult(writer));
            result = writer.getBuffer().toString();
            Document doc = documentBuilderFactory.newDocumentBuilder().parse(new InputSource(new StringReader(result)));
//            System.out.println(result);
            nodes = ((EntityJobDescriptionSource) entityJobDescriptionSource).convertToContainers("sos", doc);
        } catch (TransformerException | SAXException | IOException | ParserConfigurationException e) {
            e.printStackTrace();
        } 
        assertNotNull("Transform dbi to xml", result);
        assertNotNull("Transform dbi to ContainerNodes", nodes);
    }
}