package ru.ulstu.services;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import ru.ulstu.TimeSeriesUtils;
import ru.ulstu.models.TimeSeries;
import ru.ulstu.models.TimeSeriesValue;
import ru.ulstu.models.exceptions.ModelingException;
import ru.ulstu.tsMethods.TimeSeriesMethod;
import ru.ulstu.tsMethods.exponential.AddTrendAddSeason;
import ru.ulstu.tsMethods.exponential.NoTrendNoSeason;
import ru.ulstu.tsMethods.exponential.param.Alpha;
import ru.ulstu.tsMethods.exponential.param.Beta;
import ru.ulstu.tsMethods.exponential.param.Gamma;
import ru.ulstu.tsMethods.exponential.param.Season;
import ru.ulstu.tsMethods.exponential.param.TimeSeriesMethodParamValue;

import java.time.LocalDateTime;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;


@Service
public class TimeSeriesService {
    private static final Logger LOGGER = LoggerFactory.getLogger(TimeSeriesService.class);

    public TimeSeries getRandomTimeSeries(int length) {
        TimeSeries ts = new TimeSeries("Random time series");
        LocalDateTime dateStart = LocalDateTime.now().minusDays(length);
        for (int i = 0; i < length; i++) {
            ts.getValues().add(new TimeSeriesValue(dateStart, Math.random()));
            dateStart = dateStart.plusDays(1);
        }
        return ts;
    }

    public TimeSeries getForecast(TimeSeries timeSeries, int countPoints) throws ModelingException {
        TimeSeriesMethod method;
        method = new NoTrendNoSeason(timeSeries, new TimeSeriesMethodParamValue<>(new Alpha(), 0.8));
        method = new AddTrendAddSeason(timeSeries,
                new TimeSeriesMethodParamValue<>(new Alpha(), 0.5),
                new TimeSeriesMethodParamValue<>(new Beta(), 0.5),
                new TimeSeriesMethodParamValue<>(new Gamma(), 0.5),
                new TimeSeriesMethodParamValue<>(new Season(), 17));
        return method.getForecast(countPoints);
    }

    public TimeSeries smoothTimeSeries(TimeSeries timeSeries) throws ModelingException {
        //NoTrendNoSeason nn = new NoTrendNoSeason(timeSeries, ExponentialMethodParams.of(ExponentialParamName.ALPHA, 0.8));
        TimeSeriesMethod method;
        method = new NoTrendNoSeason(timeSeries, new TimeSeriesMethodParamValue<>(new Alpha(), 0.8));
        method = new AddTrendAddSeason(timeSeries,
                new TimeSeriesMethodParamValue<>(new Alpha(), 0.5),
                new TimeSeriesMethodParamValue<>(new Beta(), 0.5),
                new TimeSeriesMethodParamValue<>(new Gamma(), 0.5),
                new TimeSeriesMethodParamValue<>(new Season(), 17));
        return method.getModel();
    }

    public TimeSeries getTimeSeriesFromString(String tsString) {
        List<TimeSeriesValue> tsValues = Arrays.stream(tsString.split("\n"))
                .flatMap(v -> Arrays.stream(v.split(";")))
                .flatMap(v -> Arrays.stream(v.split(",")))
                .flatMap(v -> Arrays.stream(v.split("<br>")))
                .filter(v -> {
                    try {
                        Double.parseDouble(v);
                        return true;
                    } catch (NumberFormatException e) {
                        return false;
                    }
                })
                .map(Double::parseDouble)
                .map(TimeSeriesValue::new)
                .collect(Collectors.toList());
        return TimeSeriesUtils.fillDates(new TimeSeries(tsValues));
    }

    public String getTimeSeriesToString(TimeSeries timeSeries) {
        return timeSeries
                .getValues()
                .stream()
                .map(v -> v.getValue().toString().replace("\\.", ","))
                .collect(Collectors.joining(";"));
    }
}