backend/buisnesslogic/src/main/java/com/plannaplan/services/ConfiguratorService.java

package com.plannaplan.services;

import com.plannaplan.models.ConfigData;
import com.plannaplan.models.FileData;
import com.plannaplan.models.TourData;
import com.plannaplan.repositories.AppConfigRepository;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.io.InputStream;
import java.sql.Date;
import java.time.LocalDate;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

import com.plannaplan.configutils.*;
import com.plannaplan.entities.AppConfig;

/**
 * FileReader is used for reading xls file from input stream.
 */
@Component
public class ConfiguratorService {

    @Autowired
    private FileToDatabaseMigrator migrator;
    @Autowired
    private AppConfigRepository configRepo;
    @Autowired
    private EventService eventService;
    @Autowired
    private AssignmentService assignmentService;

    public ConfiguratorService() {
    }

    /**
     * methoid to config system. it shedules PerformAcceptAlgorythmTask as a side
     * effect
     * 
     * @param data ConfigData containng system configs
     */
    public void config(ConfigData data) {
        FileReader reader = new FileReader(data.getFilestream());
        FileData coursesData = reader.read();
        final AppConfig config = new AppConfig(data.getFirstTour(), data.getSecondTour());
        this.configRepo.save(config);
        migrator.migrate(coursesData);
        this.shceduleTaskAfterToursDateChange(config);
    }

    /**
     * Save tours to DataBase and shedule PerformAcceptAlgorythmTask as a side
     * effect
     * 
     * @param firstTour  First tour period.
     * @param secondTour Second tour period.
     */
    public void saveTours(TourData firstTour, TourData secondTour) {
        final AppConfig config = new AppConfig(firstTour, secondTour);
        this.configRepo.save(config);
        this.shceduleTaskAfterToursDateChange(config);
    }

    /**
     * current config getter
     * 
     * @return AppConfig with newest config_date
     */
    public AppConfig getCurrentConfig() {
        final List<AppConfig> repsonse = this.configRepo.findAll().stream().sorted(new Comparator<AppConfig>() {
            @Override
            public int compare(AppConfig i1, AppConfig i2) {
                if (i1.getConfigDate().after(i2.getConfigDate())) {
                    return -1;
                }
                if (i1.getConfigDate().before(i2.getConfigDate())) {
                    return 1;
                }
                return 0;

            }
        }).collect(Collectors.toList());

        return repsonse.get(0);
    }

    /**
     * 
     * @param inputStream This input stream contains new courses to import.
     */
    public void importCoursesStream(InputStream inputStream) {
        FileReader reader = new FileReader(inputStream);
        FileData coursesData = reader.read();
        migrator.migrate(coursesData);
    }

    private void shceduleTaskAfterToursDateChange(AppConfig config) {

        this.eventService.scheduleTask(EventService.FIRST_TOUR_SCHEDULE,
                new AlgorythmAcceptTask(config.getFirstTourEnd()), config.getFirstTourEndCron());

        this.eventService.scheduleTask(EventService.SECOND_TOUR_SCHEDULE,
                new AlgorythmAcceptTask(config.getSecondTourEnd()), config.getSecondTourEndCron());
    }

    /**
     * It's local class to perform accept Task. It's needed to be here due to have
     * acces to AssignmentService.
     */
    private class AlgorythmAcceptTask implements Runnable {

        private LocalDate localDate;

        /**
         * create instance of AlgorythmAcceptTask
         * 
         * @param date date of algorythm perform. Needed to check if ti's being called
         *             in correct year
         */
        public AlgorythmAcceptTask(Date date) {
            this.localDate = date.toLocalDate();
        }

        @Override
        public void run() {
            System.out.println("Performing event");
            if (localDate.getYear() == LocalDate.now().getYear()) {
                assignmentService.callAcceptAlgorythm();
            }

        }

    }
}