package com.company;

import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.List;
import ru.spbstu.pipeline.Status;
import ru.spbstu.pipeline.logging.Logger;
import ru.spbstu.pipeline.Executor;
import ru.spbstu.pipeline.Reader;
import ru.spbstu.pipeline.Writer;
import ru.spbstu.pipeline.logging.UtilLogger;


public class ManagerClass {
    private static final String  fileLog= "log.txt";
    private List<Executor> executors;
    private Reader reader;
    private Writer writer;
    private ru.spbstu.pipeline.logging.Logger logger;
    private Status status = Status.OK;

    public ManagerClass(String configFile){
        java.util.logging.Logger utilLogger = java.util.logging.Logger.getLogger(fileLog);
        logger = UtilLogger.of(utilLogger);
        buildPipeline(configFile);
    }

    public ManagerClass(String configFile, ru.spbstu.pipeline.logging.Logger logger){
        this.logger = logger;
        buildPipeline(configFile);
    }

    private int checkWorkers(){
        if(status != Status.OK)
            return -1;

        boolean hasNullWorker = (reader == null) || (writer == null);
        for (Executor ex: executors) hasNullWorker |= (ex == null);
        if(hasNullWorker){
            status = Status.ERROR;
            logger.log("Error in Transporter: unable to launch - a worker is missing");
            return -1;
        }

        boolean workersAreOK = (reader.status() == Status.OK) && (writer.status() == Status.OK);
        for(Executor ex: executors) workersAreOK &= (ex.status() == Status.OK);
        if(!workersAreOK){
            status = Status.ERROR;
            logger.log("Error in Transporter: pipeline is built successfully, but not all workers are OK");
            return -1;
        }
        return 0;
    }

    public void run(){
        if (checkWorkers() != 0) {
            status = Status.ERROR;
            logger.log("Transporter not ready to run.");
            return;
        }
        reader.run();
    }

    private void buildPipeline(String configFile){
        ParseConfigFile parser = new ParseConfigFile(configFile, logger);
        if(parser.getStatus() != Status.OK){
            status = Status.ERROR;
            logger.log("Error status is not OK");
            return;
        }
        executors = new ArrayList<>();
        Delimiter readerParam =  parser.reader();
        Delimiter writerParam =  parser.writer();
        Delimiter [] executorParams = parser.executors();
        try{
            Class readerExtra = Class.forName(readerParam.className);
            String readerConfig = readerParam.configFilename;
            Class[] readerParameter ={String.class, ru.spbstu.pipeline.logging.Logger.class};//int/class
            reader = (ReaderClass) readerExtra.getConstructor(readerParameter).newInstance(readerParam.configFilename, logger);
        } catch (ClassNotFoundException | NullPointerException e){
            status = Status.ERROR;
            logger.log("Error no such class: " + readerParam.className);
        } catch (NoSuchMethodException | IllegalAccessException | InstantiationException e){
            status = Status.ERROR;
            logger.log("Error class " + readerParam.className + " doesn't implement constructor");
        } catch (InvocationTargetException e){
            status = Status.ERROR;
            logger.log("Error exception thrown in constructor");
        }
        try{
            Class writerExtra = Class.forName(writerParam.className);
            String writerConfig = writerParam.configFilename;
            Class[] writerParameter ={String.class, ru.spbstu.pipeline.logging.Logger.class};
            writer = (WriterClass) writerExtra.getConstructor(writerParameter).newInstance(writerParam.configFilename, logger);
        } catch (ClassNotFoundException | NullPointerException e){
            status = Status.ERROR;
            logger.log("Error no such class: " + writerParam.className);
        } catch (NoSuchMethodException | IllegalAccessException | InstantiationException e){
            status = Status.ERROR;
            logger.log("Error class " + writerParam.className + " doesn't implement constructor");
        } catch (InvocationTargetException e){
            status = Status.ERROR;
            logger.log("Error exception thrown in constructor");
        }
        if(executorParams.length == 0){
            if(checkWorkers() != 0) return;
            reader.addConsumer(writer);
            writer.addProducer(reader);
        } else {
            for (Delimiter executorParam: executorParams) {
                Executor executor = null;
                try{
                    Class executorExtra = Class.forName(executorParam.className);
                    String executorConfig = executorParam.configFilename;
                    Class[] executorParameter ={String.class, ru.spbstu.pipeline.logging.Logger.class};
                    executor = (ExecutorClass) executorExtra.getConstructor(executorParameter).newInstance(executorParam.configFilename, logger);
                    executors.add(executor);
                } catch (ClassNotFoundException | NullPointerException e){
                    status = Status.ERROR;
                    logger.log("Error no such class: " + executorParam.className);
                } catch (NoSuchMethodException | IllegalAccessException | InstantiationException e){
                    status = Status.ERROR;
                    logger.log("Error class " + executorParam.className + " doesn't implement constructor");
                } catch (InvocationTargetException e){
                    status = Status.ERROR;
                    logger.log("Error exception thrown in constructor");
                }
            }
            if(checkWorkers() != 0) return;
            for (int i = 1; i < executors.size(); i++){
                executors.get(i-1).addConsumer(executors.get(i));
                executors.get(i).addProducer(executors.get(i-1));
            }
            reader.addConsumer(executors.get(0));
            executors.get(0).addProducer(reader);
            writer.addProducer(executors.get(executors.size() - 1));
            executors.get(executors.size() - 1).addConsumer(writer);
        }
    }

}