package cz.senslog.analyzer.analysis;

import cz.senslog.analyzer.analysis.module.FilterHandler;
import cz.senslog.analyzer.analysis.module.HandlersModule;
import cz.senslog.analyzer.analysis.module.ThresholdHandler;
import cz.senslog.analyzer.core.EventBusModule;
import cz.senslog.analyzer.core.api.BlockingHandler;
import cz.senslog.analyzer.core.EventBus;
import cz.senslog.analyzer.core.api.HandlerInvoker;
import cz.senslog.analyzer.domain.DoubleStatistics;
import cz.senslog.analyzer.domain.Observation;

import dagger.Module;
import dagger.Provides;

import javax.inject.Named;

import java.util.List;

import static cz.senslog.analyzer.core.api.HandlerInvoker.cancelInvoker;


@Module(includes = {
        HandlersModule.class,
        EventBusModule.class
})
public class AnalyzerModule {

    @Provides @Named("advancedAnalyzer")
    Analyzer provideAdvancedAnalyzer (
            @Named("sensorFilterHandler") FilterHandler<Observation> sensorFilterHandler,
            @Named("sensorThresholdHandler") ThresholdHandler<Observation> thresholdHandler,
            @Named("observationCollector") BlockingHandler<Observation, DoubleStatistics> observationCollector,
            @Named("groupFilterHandler") FilterHandler<DoubleStatistics> groupFilterHandler,
            @Named("groupThresholdHandler") ThresholdHandler<DoubleStatistics> groupThresholdHandler,
            @Named("statisticsCollector") BlockingHandler<DoubleStatistics, DoubleStatistics> statisticsCollector,
            EventBus eventBus
    ) {
        HandlerInvoker<Observation> invoker = HandlerInvoker.create()
                .handler(sensorFilterHandler)
                .nextHandlerInvoker(HandlerInvoker.create()
                        .handler(thresholdHandler)
                        .nextHandlerInvoker(HandlerInvoker.create()
                                .blockingHandler(observationCollector, eventBus::save)
                                .nextHandlerInvoker(HandlerInvoker.create()
                                        .handler(groupFilterHandler)
                                        .nextHandlerInvoker(HandlerInvoker.create()
                                                .handler(groupThresholdHandler)
                                                .nextHandlerInvoker(HandlerInvoker.create()
                                                        .blockingHandler(statisticsCollector, eventBus::save)
                                                        .nextHandlerInvoker(cancelInvoker())
                                                        .eventBus(eventBus)
                                                        .build()
                                                ).eventBus(eventBus)
                                                .build()
                                        ).eventBus(eventBus)
                                        .build()
                                ).eventBus(eventBus)
                                .build()
                        ).eventBus(eventBus)
                        .build()
                ).eventBus(eventBus)
                .build();

        return new ObservationAnalyzer(invoker);
    }

    @Provides @Named("simpleAnalyzer")
    Analyzer provideSimpleAnalyzer (
            @Named("sensorFilterHandler") FilterHandler<Observation> sensorFilterHandler,
            @Named("sensorThresholdHandler") ThresholdHandler<Observation> thresholdHandler,
            @Named("observationCollector") BlockingHandler<Observation, DoubleStatistics> observationCollector,
            EventBus eventBus
    ) {
        HandlerInvoker<Observation> obsColl = HandlerInvoker.create()
                .blockingHandler(observationCollector, eventBus::save)
                .nextHandlerInvoker(cancelInvoker()).eventBus(eventBus)
                .build();

        HandlerInvoker<Observation> obsThs = HandlerInvoker.create().handler(thresholdHandler)
                .nextHandlerInvoker(obsColl).eventBus(eventBus).build();

        HandlerInvoker<Observation> obsFlt = HandlerInvoker.create().handler(sensorFilterHandler)
                .nextHandlerInvoker(obsThs).eventBus(eventBus).build();

        return new ObservationAnalyzer(obsFlt);
    }
}