package com.upnetix.java.plexnikolaygeorgiev.repositories.external;

import com.upnetix.java.plexnikolaygeorgiev.entities.external.SourceAudioCodecs;
import com.upnetix.java.plexnikolaygeorgiev.entities.external.SourceEpisode;
import com.upnetix.java.plexnikolaygeorgiev.entities.external.SourceMediaExtended;
import com.upnetix.java.plexnikolaygeorgiev.entities.external.SourceMediaStream;
import com.upnetix.java.plexnikolaygeorgiev.entities.external.SourceMovie;
import com.upnetix.java.plexnikolaygeorgiev.entities.external.SourceSeason;
import com.upnetix.java.plexnikolaygeorgiev.entities.external.SourceSeries;
import com.upnetix.java.plexnikolaygeorgiev.entities.external.SourceSubtitleCodecs;
import com.upnetix.java.plexnikolaygeorgiev.exceptions.ExternalDatabaseException;
import com.upnetix.java.plexnikolaygeorgiev.repositories.external.utils.SourceRepositoryUtils;
import com.upnetix.java.plexnikolaygeorgiev.services.DbMigrationService;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import javax.sql.DataSource;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.EnumUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;
import org.springframework.stereotype.Repository;


import static com.upnetix.java.plexnikolaygeorgiev.entities.external.SourceConstants.CODEC;
import static com.upnetix.java.plexnikolaygeorgiev.entities.external.SourceConstants.FETCH_SIZE;
import static com.upnetix.java.plexnikolaygeorgiev.entities.external.SourceConstants.LANGUAGE;
import static com.upnetix.java.plexnikolaygeorgiev.entities.external.SourceConstants.MOVIES_QUERY;
import static com.upnetix.java.plexnikolaygeorgiev.entities.external.SourceConstants.SERIES_SEASONS_EPISODES_QUERY;
import static com.upnetix.java.plexnikolaygeorgiev.entities.external.SourceConstants.STREAM_QUERY;
import static com.upnetix.java.plexnikolaygeorgiev.entities.external.SourceConstants.STREAM_TYPE_ID_2;
import static com.upnetix.java.plexnikolaygeorgiev.entities.external.SourceConstants.STREAM_TYPE_ID_3;
import static com.upnetix.java.plexnikolaygeorgiev.logger.LoggerMessages.CONNECTION_ERROR;
import static com.upnetix.java.plexnikolaygeorgiev.logger.LoggerMessages.MIGRATION_PROCESS_COMPLETED;
import static com.upnetix.java.plexnikolaygeorgiev.logger.LoggerMessages.MOVIE_FETCHING;
import static com.upnetix.java.plexnikolaygeorgiev.logger.LoggerMessages.MOVIE_MIGRATION;
import static com.upnetix.java.plexnikolaygeorgiev.logger.LoggerMessages.SERIES_FETCHING;
import static com.upnetix.java.plexnikolaygeorgiev.logger.LoggerMessages.SERIES_MIGRATION;
import static com.upnetix.java.plexnikolaygeorgiev.logger.MigrationProgress.COMPLETED_MOVIES_SERIES_MIGRATION;
import static com.upnetix.java.plexnikolaygeorgiev.logger.MigrationProgress.FETCHING_MOVIES;
import static com.upnetix.java.plexnikolaygeorgiev.logger.MigrationProgress.FETCHING_SERIES;
import static com.upnetix.java.plexnikolaygeorgiev.logger.MigrationProgress.MIGRATING_MOVIES;
import static com.upnetix.java.plexnikolaygeorgiev.logger.MigrationProgress.MIGRATING_SERIES;

@Repository
@Slf4j
public class SourceRepositoryImpl implements SourceRepository {
  @Value("${url.start}")
  private String urlStart;
  private DataSource dataSource;
  private DbMigrationService migrationService;
  private Connection connection;
  @Value("${upload.file.directory}")
  private String uploadDirectory;
  private ConcurrentMap<String, Integer> progress = new ConcurrentHashMap<>();
  private boolean hasFinished;

  @Autowired
  public SourceRepositoryImpl(@Qualifier("sqliteDataSource") DataSource dataSource, DbMigrationService migrationService) {
    this.dataSource = dataSource;
    this.migrationService = migrationService;
  }


  @Override
  public void fetchMedia(String jwt, String fileName) throws SQLException {
    if (StringUtils.isEmpty(fileName)) {
      log.error(CONNECTION_ERROR);
      throw new ExternalDatabaseException(CONNECTION_ERROR);
    }
    synchronized (this) {
      dataSource = DataSourceBuilder.create().url(urlStart + uploadDirectory + fileName).build();
      connection = dataSource.getConnection();
      fetchMovies(jwt);
      fetchSeries(jwt);
      connection.close();
    }
    log.info(MIGRATION_PROCESS_COMPLETED);
    progress.put(jwt, COMPLETED_MOVIES_SERIES_MIGRATION.getStep());
    hasFinished = true;
  }

  @Override
  public int getStatus(String jwt) {
    if (hasFinished) {
      hasFinished = false;
      int result = this.progress.getOrDefault(jwt, 0);
      this.progress.put(jwt, 0);
      return result;
    }
    return this.progress.getOrDefault(jwt, 0);
  }

  private void fetchMovies(String jwt) throws SQLException {
    progress.put(jwt, FETCHING_MOVIES.getStep());
    log.info(MOVIE_FETCHING);
    PreparedStatement statement = connection.prepareStatement(MOVIES_QUERY);
    SourceRepositoryUtils.prepareMoviesStatement(statement);

    ResultSet resultSet = statement.executeQuery();
    List<SourceMovie> sourceMovies = new ArrayList<>(FETCH_SIZE);
    while (resultSet.next()) {
      SourceMovie sourceMovie = SourceMovie.generateFromResultSet(resultSet);

      sourceMovies.add(sourceMovie);
    }

    sourceMovies = removeDuplicates(sourceMovies);

    for (SourceMovie sourceMovie : sourceMovies) {
      setStreamsToMedia(sourceMovie);
    }

    progress.put(jwt, MIGRATING_MOVIES.getStep());
    log.info(MOVIE_MIGRATION);
    migrationService.migrateMovies(sourceMovies);
    statement.close();
  }

  private List<SourceMovie> removeDuplicates(List<SourceMovie> sourceMovies) {
    List<SourceMovie> result = new ArrayList<>(sourceMovies.size());

    for (SourceMovie sourceMovie : sourceMovies) {
      if (!result.contains(sourceMovie)) {
        result.add(sourceMovie);
      }
    }

    return result;
  }


  private void fetchSeries(String jwt) throws SQLException {
    progress.put(jwt, FETCHING_SERIES.getStep());
    log.info(SERIES_FETCHING);
    PreparedStatement statement = connection.prepareStatement(SERIES_SEASONS_EPISODES_QUERY);
    SourceRepositoryUtils.prepareSeriesStatement(statement);
    ResultSet resultSet = statement.executeQuery();
    List<SourceSeries> seriesResults = new ArrayList<>(100);

    while (resultSet.next()) {
      SourceSeries sourceSeries = SourceSeries.generateFromResultSet(resultSet);
      generateContentForSeries(resultSet, sourceSeries, seriesResults);
    }

    progress.put(jwt, MIGRATING_SERIES.getStep());
    log.info(SERIES_MIGRATION);
    migrationService.migrateSeries(seriesResults);
    statement.close();
  }

  private void generateContentForSeries(ResultSet resultSet, SourceSeries sourceSeries,
      List<SourceSeries> seriesResults) throws SQLException {
    if (seriesResults.contains(sourceSeries)) {
      sourceSeries = seriesResults.remove(seriesResults.indexOf(sourceSeries));
    }
    SourceSeason sourceSeason = SourceSeason.generateFromResultSet(resultSet, sourceSeries);
    if (sourceSeries.getSeasons() != null && sourceSeries.getSeasons().contains(sourceSeason)) {
      sourceSeason = sourceSeries.getSeasons().remove(sourceSeries.getSeasons().indexOf(sourceSeason));
    }
    SourceEpisode sourceEpisode = SourceEpisode.generateFromResultSet(resultSet, sourceSeason);

    setStreamsToMedia(sourceEpisode);

    sourceSeason.addEpisode(sourceEpisode);
    sourceSeries.addSeason(sourceSeason);
    seriesResults.add(sourceSeries);
  }

  private List<SourceMediaStream> fetchStream(Long metadataItemId) throws SQLException {
    PreparedStatement statement = connection.prepareStatement(STREAM_QUERY);
    statement.setInt(1, STREAM_TYPE_ID_2);
    statement.setInt(2, STREAM_TYPE_ID_3);
    statement.setLong(3, metadataItemId);
    ResultSet resultSet = statement.executeQuery();
    List<SourceMediaStream> results = new ArrayList<>(2);

    while (resultSet.next()) {
      SourceMediaStream sourceMediaStream = new SourceMediaStream();
      sourceMediaStream.setCodec(resultSet.getString(CODEC));
      sourceMediaStream.setLanguage(resultSet.getString(LANGUAGE));
      results.add(sourceMediaStream);
    }

    statement.close();
    return results;
  }

  private void setStreamsToMedia(SourceMediaExtended sourceMedia) throws SQLException {
    List<SourceMediaStream> mediaStreams = fetchStream(Long.valueOf(sourceMedia.getId()));
    for (SourceMediaStream mediaStream : mediaStreams) {
      if (EnumUtils.isValidEnum(SourceSubtitleCodecs.class, mediaStream.getCodec().toUpperCase())
          && mediaStream.getLanguage().length() > 0) {
        sourceMedia.addSubtitles(mediaStream.getLanguage());
      }
      if (EnumUtils.isValidEnum(SourceAudioCodecs.class, mediaStream.getCodec().toUpperCase())
          && mediaStream.getLanguage().length() > 0) {
        sourceMedia.addAudio(mediaStream.getLanguage());
      }
    }
  }
}