package org.gcube.application.cms.plugins.implementations;

import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import org.gcube.application.cms.plugins.LifecycleManager;
import org.gcube.application.cms.plugins.PluginManagerInterface;
import org.gcube.application.cms.plugins.faults.*;
import org.gcube.application.cms.plugins.model.StepAccess;
import org.gcube.application.cms.plugins.reports.EventExecutionReport;
import org.gcube.application.cms.plugins.reports.InitializationReport;
import org.gcube.application.cms.plugins.reports.Report;
import org.gcube.application.cms.plugins.reports.StepExecutionReport;
import org.gcube.application.cms.plugins.requests.BaseRequest;
import org.gcube.application.cms.plugins.requests.EventExecutionRequest;
import org.gcube.application.cms.plugins.requests.StepExecutionRequest;
import org.gcube.application.cms.serialization.Serialization;
import org.gcube.application.geoportal.common.model.configuration.Configuration;
import org.gcube.application.geoportal.common.model.document.accounting.User;
import org.gcube.application.geoportal.common.model.document.lifecycle.LifecycleInformation;
import org.gcube.application.geoportal.common.model.document.lifecycle.TriggeredEvents;
import org.gcube.application.geoportal.common.model.rest.ConfigurationException;
import org.gcube.application.geoportal.common.model.useCaseDescriptor.HandlerDeclaration;
import org.gcube.application.geoportal.common.utils.ContextUtils;

import java.util.List;

@Slf4j
public abstract class AbstractLifeCycleManager extends AbstractPlugin implements LifecycleManager {

    @Setter
    protected PluginManagerInterface pluginManager;


    @Override
    public StepExecutionReport performStep(StepExecutionRequest request) throws StepException, InvalidPluginRequestException, InvalidProfileException, ConfigurationException, InsufficientPrivileges {
        log.info("Serving Request {}",request);
        StepExecutionReport report=new StepExecutionReport(request);
        report.setStatus(Report.Status.OK);

        if(!canInvokeStep(request.getStep(),request.getCaller(),
                getConfigurationFromProfile(request.getUseCaseDescriptor())))
            throw new InsufficientPrivileges("User is not allowed to invoke "+request.getStep());


        LifecycleInformation info=report.getToSetLifecycleInformation();
        info.setLastOperationStatus(LifecycleInformation.Status.OK);
        info.setLastInvokedStep(request.getStep());

        return report;
    }


    protected static boolean canInvokeStep(String stepID, User u, HandlerDeclaration config) throws ConfigurationException {
        log.debug("Checking if {} can access STEP {}",u,stepID);
        log.trace("Config is {}",config);
        List l =config.getConfiguration().get("step_access", List.class);
        if(l==null|| l.isEmpty()) throw new ConfigurationException("Missing Role management in UCD");
        for (Object o : l) {
            StepAccess a= Serialization.convert(o,StepAccess.class);
            if(a.getStepId().equals(stepID)){
                // found step ID
                log.trace("Found Step ID declaration {} ",a);
                for (String s : a.getRoles()) {
                    if (u.getRoles().contains(s))
                        return true;
                }
            }
        }
        return false;
    }


    @Override
    public InitializationReport initInContext() throws InitializationException {
        InitializationReport report = new InitializationReport();
        try{
            report.setStatus(Report.Status.OK);
        } catch (Throwable e) {
            log.error("Unable to initialize plugins in {} ", ContextUtils.getCurrentScope(),e);
            report.setStatus(Report.Status.WARNING);
            report.putMessage("Unable to initialize plugins in "+ ContextUtils.getCurrentScope()+" : "+e.getMessage());
        }
        return report;
    }

    @Override
    public InitializationReport init() throws InitializationException {
        InitializationReport report = new InitializationReport();
        try{
            report.setStatus(Report.Status.OK);

        } catch (Throwable e) {
            log.error("Unable to initialize plugins ",e);
            report.setStatus(Report.Status.WARNING);
            report.putMessage("Unable to initialize plugins : "+e.getMessage());
        }
        return report;
    }

    @Override
    public void shutdown() throws ShutDownException {}

    @Override
    public Configuration getCurrentConfiguration(BaseRequest request) throws ConfigurationException {
        return new Configuration();
    }

    @Override
    public EventExecutionReport onEvent(EventExecutionRequest request) throws EventException, InvalidPluginRequestException {
        log.info("Executing Event {}",request);
        EventExecutionReport report=new EventExecutionReport(request);

        TriggeredEvents info=new TriggeredEvents();
        info.setEvent(request.getEvent());
        info.setLastOperationStatus(LifecycleInformation.Status.OK);
        report.setStatus(Report.Status.OK);
        report.getToSetLifecycleInformation().addEventReport(info);
        return report;
   }
}