/*
 * Copyright (C) 2000 - 2026 Silverpeas
 *
 * This program is free software: you can redistribute it and/or modify it under the terms of the
 * GNU Affero General Public License as published by the Free Software Foundation, either version 3
 * of the License, or (at your option) any later version.
 *
 * As a special exception to the terms and conditions of version 3.0 of the GPL, you may
 * redistribute this Program in connection with Free/Libre Open Source Software ("FLOSS")
 * applications as described in Silverpeas's FLOSS exception. You should have received a copy of the
 * text describing the FLOSS exception, and it is also available here:
 * "http://www.silverpeas.org/docs/core/legal/floss_exception.html"
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
 * even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License along with this program.
 * If not, see <https://www.gnu.org/licenses/>.
 */
package org.silverpeas.components.kmelia.stats;

import org.silverpeas.components.kmelia.model.StatisticActivityVO;
import org.silverpeas.components.kmelia.model.StatsFilterVO;
import org.silverpeas.core.ResourceReference;
import org.silverpeas.core.admin.service.AdminException;
import org.silverpeas.core.admin.user.model.Group;
import org.silverpeas.core.annotation.Service;
import org.silverpeas.core.contribution.publication.model.PublicationDetail;
import org.silverpeas.core.contribution.publication.service.PublicationService;
import org.silverpeas.core.node.model.NodeDetail;
import org.silverpeas.core.node.model.NodePK;
import org.silverpeas.core.node.service.NodeService;
import org.silverpeas.core.silverstatistics.access.service.StatisticService;
import org.silverpeas.kernel.util.Pair;
import org.silverpeas.kernel.logging.SilverLogger;

import javax.inject.Inject;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

import static java.time.OffsetDateTime.now;
import static org.silverpeas.core.admin.service.AdministrationServiceProvider.getAdminService;
import static org.silverpeas.core.contribution.publication.dao.PublicationCriteria.onComponentInstanceIds;
import static org.silverpeas.core.contribution.publication.model.PublicationDetail.VALID_STATUS;

@Service
public class StatisticServiceImpl implements
    org.silverpeas.components.kmelia.stats.StatisticService {

  private static final String PUBLICATION_TYPE = "Publication";
  @Inject
  private PublicationService publicationService;
  @Inject
  private NodeService nodeService;
  @Inject
  private StatisticService statisticService;

  @Override
  public Integer getNbConsultedPublication(StatsFilterVO statFilter) {
    if (statFilter != null) {
      return getNumberOfConsultedPublications(statFilter);
    }
    return -1;
  }

  @Override
  public Integer getNbStatisticActivityByPeriod(StatsFilterVO statFilter) {
    if (statFilter != null) {
      // Retrieve the list of topic application publications
      List<PublicationDetail> publis = getValidApplicationPublications(statFilter);
      if (!publis.isEmpty()) {
        return (int)countGlobalPublicationActivity(statFilter, publis);
      }
      return 0;
    }
    return -1;
  }

  private Integer getNumberOfConsultedPublications(StatsFilterVO statFilter) {
    List<PublicationDetail> publis = getValidApplicationPublications(statFilter);
    int nbPubli = 0;
    if (!publis.isEmpty()) {
      Integer groupId = statFilter.getGroupId();
      List<ResourceReference> publiPKs = getReferencesToPublications(publis);
      if (groupId != null) {
        // Retrieve the list of user identifiers
        List<String> userIds = getListUserIdsFromGroup(groupId);
        try {
          // Retrieve the number of publication
          nbPubli = getStatisticService().getCountByPeriodAndUser(publiPKs, PUBLICATION_TYPE,
              statFilter.getStartDate(), statFilter.getEndDate(), userIds);

        } catch (Exception e) {
          SilverLogger.getLogger(this)
              .error("Error when counting number of access (getCountByPeriodAndUser)", e);
        }

      } else {
        try {
          nbPubli = getStatisticService().getCountByPeriod(publiPKs, 1, PUBLICATION_TYPE,
              statFilter.getStartDate(), statFilter.getEndDate());
        } catch (Exception e) {
          SilverLogger.getLogger(this)
              .error("Error when counting number of access (getCountByPeriod)", e);
        }

      }
    }
    return nbPubli;
  }

  /**
   * @param publis the list of publication detail where we extract WAPrimaryKey
   * @return a list of references to the specified publications
   */
  private List<ResourceReference> getReferencesToPublications(List<PublicationDetail> publis) {
    List<ResourceReference> publiPKs = new ArrayList<>();
    // Check access for each publication
    for (PublicationDetail publi : publis) {
      publiPKs.add(new ResourceReference(publi.getPK()));
    }
    return publiPKs;
  }

  /**
   * @param groupId the group identifier
   * @return the list of user identifiers which are linked to a group given in parameter, or empty
   * list if an exception occurs
   */
  private List<String> getListUserIdsFromGroup(Integer groupId) {
    List<String> userIds = new ArrayList<>();
    try {
      Group selectedGroup = getAdminService().getGroup(Integer.toString(groupId));
      String[] arrayUserIds = selectedGroup.getUserIds();
      Collections.addAll(userIds, arrayUserIds);
    } catch (AdminException e) {
      SilverLogger.getLogger(this).error("Error when loading the list of filtered users", e);
    }
    return userIds;
  }

  /**
   * @param statFilter the stats filter value object
   * @return the list of application publications which respects the stats filter constraint
   */
  private List<PublicationDetail> getValidApplicationPublications(StatsFilterVO statFilter) {
    final NodePK fatherPK = new NodePK(Integer.toString(statFilter.getTopicId()),
        statFilter.getInstanceId());
    return getPublicationService().getPublicationsByCriteria(
        onComponentInstanceIds(statFilter.getInstanceId()).onNodes(
            getNodeService().getSubTree(fatherPK)
                .stream()
                .map(NodeDetail::getId)
                .collect(Collectors.toSet()))
            .ofStatus(VALID_STATUS)
            .visibleAt(now()));
  }

  /**
   * @param statFilter the statistic filter object which contains all the statistic constraints
   * @param publis the list of PublicationDetail
   * @param isCreate true if counting create publication activity
   * @param isUpdate true if counting update publication activity
   * @return the number of global (create/modify) activity which happens on the list of publications
   */
  private long countPublicationActivity(StatsFilterVO statFilter,
      Collection<PublicationDetail> publis, boolean isCreate, boolean isUpdate) {
    long nbPubli;
    Date startTime = statFilter.getStartDate();
    Date endTime = statFilter.getEndDate();
    Integer groupId = statFilter.getGroupId();

    if (groupId != null) {
      List<String> userIds = getListUserIdsFromGroup(groupId);
      if (!userIds.isEmpty()) {
        nbPubli = publis.stream()
            .filter(
                p -> isPubliActivityInsideTimeInterval(startTime, endTime, p, isCreate, isUpdate))
            .flatMap(p -> userIds.stream().map(u -> Pair.of(p, u)))
            .filter(pu -> isUserRelatedWithPubli(pu.getFirst(), pu.getSecond()))
            .count();
      } else {
        nbPubli = 0;
      }
    } else {
      // Check activity for each publication
      nbPubli = publis.stream()
          .filter(p -> isPubliActivityInsideTimeInterval(startTime, endTime, p, isCreate, isUpdate))
          .count();
    }
    return nbPubli;
  }

  /**
   * @param publi the publication detail
   * @param userId the user identifier
   * @return true if user has created, modified or validate this publication
   */
  private boolean isUserRelatedWithPubli(PublicationDetail publi, String userId) {
    return (userId.equals(publi.getCreatorId()) || userId.equals(publi.getUpdaterId()) || userId
        .equals(publi.getValidatorId()));
  }

  /**
   * @param startTime the start time interval
   * @param endTime the end time interval
   * @param publi the publication detail
   * @param isCreate true if check Create activity
   * @param isUpdate true if check Update activity
   * @return true if publication creation date and isCreate or modification date and isUpdate is
   * between startTime and endTime
   */
  private boolean isPubliActivityInsideTimeInterval(Date startTime, Date endTime,
      PublicationDetail publi, boolean isCreate, boolean isUpdate) {
    Date createDate = publi.getCreationDate();
    Date updateDate = publi.getLastUpdateDate();
    return (isCreate && (createDate.after(startTime) || createDate.equals(startTime)) && createDate.
        before(endTime)) || (isUpdate && (updateDate.after(startTime) || updateDate.
        equals(startTime)) && updateDate
        .before(endTime));
  }

  private PublicationService getPublicationService() {
    return publicationService;
  }

  private NodeService getNodeService() {
    return nodeService;
  }

  private StatisticService getStatisticService() {
    return statisticService;
  }

  @Override
  public StatisticActivityVO getStatisticActivity(StatsFilterVO statFilter) {
    List<PublicationDetail> publis = getValidApplicationPublications(statFilter);
    long nbCreate = countCreatePublicationActivity(statFilter, publis);
    long nbUpdate = countUpdatePublicationActivity(statFilter, publis);
    return new StatisticActivityVO((int)nbCreate, (int)nbUpdate);
  }

  /**
   * @param statFilter the statistic filter object which contains all the statistic constraints
   * @param publis the list of PublicationDetail
   * @return the number of global (create/modify) activity which happens on the list of publications
   */
  private long countCreatePublicationActivity(StatsFilterVO statFilter,
      List<PublicationDetail> publis) {
    return countPublicationActivity(statFilter, publis, true, false);
  }

  /**
   * @param statFilter the statistic filter object which contains all the statistic constraints
   * @param publis the list of PublicationDetail
   * @return the number of global (create/modify) activity which happens on the list of publications
   */
  private long countUpdatePublicationActivity(StatsFilterVO statFilter,
      List<PublicationDetail> publis) {
    return countPublicationActivity(statFilter, publis, false, true);
  }

  /**
   * @param statFilter the statistic filter object which contains all the statistic constraints
   * @param publis the list of PublicationDetail
   * @return the number of global (create/modify) activity which happens on the list of publications
   */
  private long countGlobalPublicationActivity(StatsFilterVO statFilter,
      List<PublicationDetail> publis) {
    return countPublicationActivity(statFilter, publis, true, true);
  }

  @Override
  public Integer getNumberOfDifferentConsultedPublications(StatsFilterVO statFilter) {
    if (statFilter != null) {
      List<PublicationDetail> publis = getValidApplicationPublications(statFilter);
      if (!publis.isEmpty()) {
        return countDistinctConsultedPublications(statFilter, publis);
      }
    }
    return -1;
  }

  /**
   * @param statFilter the statistic filter which contains all the statistics filter parameters
   * @param publis the list of publications
   * @return the number of distinct consulted publications
   */
  private Integer countDistinctConsultedPublications(StatsFilterVO statFilter,
      List<PublicationDetail> publis) {
    int nbPubli = 0;
    List<ResourceReference> publiPKs = getReferencesToPublications(publis);
    if (statFilter.getGroupId() != null) {
      // Retrieve the list of user identifiers
      List<String> userIds = getListUserIdsFromGroup(statFilter.getGroupId());
      try {
        return getStatisticService().getDistinctCountByPeriodUser(publiPKs, 1, PUBLICATION_TYPE,
            statFilter.getStartDate(), statFilter.getEndDate(), userIds);
      } catch (Exception e) {
        SilverLogger.getLogger(this)
            .error("Error when computing distinct access to publication", e);
      }
    } else {
      try {
        return getStatisticService().getDistinctCountByPeriod(publiPKs, 1, PUBLICATION_TYPE,
            statFilter.getStartDate(), statFilter.getEndDate());
      } catch (Exception e) {
        SilverLogger.getLogger(this)
            .error("Error when computing distinct access to publication", e);
      }
    }
    return nbPubli;
  }
}
