/*
 * 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:
 * "https://www.silverpeas.org/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.whitepages.control;

import org.silverpeas.components.whitepages.WhitePagesException;
import org.silverpeas.components.whitepages.model.Card;
import org.silverpeas.components.whitepages.model.SilverCard;
import org.silverpeas.components.whitepages.model.WhitePagesCard;
import org.silverpeas.components.whitepages.record.UserRecord;
import org.silverpeas.core.WAPrimaryKey;
import org.silverpeas.core.admin.user.model.User;
import org.silverpeas.core.admin.user.model.UserDetail;
import org.silverpeas.core.annotation.Service;
import org.silverpeas.core.contribution.content.form.Field;
import org.silverpeas.core.contribution.content.form.FormException;
import org.silverpeas.core.contribution.content.form.RecordSet;
import org.silverpeas.core.contribution.contentcontainer.content.ContentManagementEngine;
import org.silverpeas.core.contribution.contentcontainer.content.ContentManagementEngineProvider;
import org.silverpeas.core.contribution.contentcontainer.content.ContentManagerException;
import org.silverpeas.core.contribution.template.publication.PublicationTemplate;
import org.silverpeas.core.contribution.template.publication.PublicationTemplateManager;
import org.silverpeas.core.index.indexing.model.FullIndexEntry;
import org.silverpeas.core.index.indexing.model.IndexEngineProxy;
import org.silverpeas.core.index.indexing.model.IndexEntryKey;
import org.silverpeas.core.pdc.pdc.model.ClassifyPosition;
import org.silverpeas.core.pdc.pdc.model.PdcClassification;
import org.silverpeas.core.pdc.pdc.model.PdcException;
import org.silverpeas.core.pdc.pdc.service.PdcManager;
import org.silverpeas.core.persistence.jdbc.DBUtil;
import org.silverpeas.core.persistence.jdbc.bean.*;
import org.silverpeas.core.util.DateUtil;
import org.silverpeas.core.util.ServiceProvider;
import org.silverpeas.kernel.logging.SilverLogger;

import javax.inject.Inject;
import java.sql.Connection;
import java.sql.SQLException;
import java.text.ParseException;
import java.util.*;
import java.util.stream.Collectors;

@SuppressWarnings("deprecation")
@Service
public class CardManager {

  private static final String INSTANCE_ID = "instanceId";
  private static final String HIDE_STATUS = "hideStatus";
  private static final String USER_ID = "userId";
  @Inject
  private WhitePagesContentManager contentManager;

  protected CardManager() {
  }

  private WhitePagesContentManager getWhitePagesContentManager() {
    return contentManager;
  }

  public static CardManager getInstance() {
    return ServiceProvider.getService(CardManager.class);
  }

  public long create(Card card, String creatorId, PdcClassification classification)
      throws WhitePagesException {
    long id = -1;

    Connection con = null;
    try {
      SilverpeasBeanDAO<Card> dao = getCardDAO();
      con = DBUtil.openConnection();
      con.setAutoCommit(false);

      card.setCreationDate(DateUtil.date2SQLDate(new Date()));
      card.setCreatorId(Integer.parseInt(creatorId));

      WAPrimaryKey pk = dao.add(con, card);
      id = Long.parseLong(pk.getId());
      card.setPK(pk);

      int silverContentId = getWhitePagesContentManager().createSilverContent(con, card);

      indexCard(card);
      con.commit();

      // classify the contribution on the PdC if its classification is defined
      if (classification != null && !classification.isEmpty()) {
        SilverCard silverCard = new SilverCard(card, silverContentId);
        classification.classifyContent(silverCard);
      }

    } catch (Exception e) {
      rollback(con, e);
    } finally {
      closeConnection(con);
    }

    return id;
  }

  public void delete(Collection<String> ids) throws WhitePagesException {
    Connection con = null;

    if (ids != null) {
      try {
        con = DBUtil.openConnection();
        con.setAutoCommit(false);

        SilverpeasBeanDAO<Card> dao = getCardDAO();

        IdPK pk = new IdPK();
        String peasId = null;

        for (String id : ids) {
          pk.setId(id);

          // le premier element donne l'id de l'instance.
          if (peasId == null) {
            Card card = getCard(Long.parseLong(pk.getId()));
            if (card == null) {
              continue;
            } else {
              peasId = card.getInstanceId();
            }
          }
          dao.remove(con, pk);

          // suppression de la reference par le content maneger.
          pk.setComponentName(peasId);
          getWhitePagesContentManager().deleteSilverContent(con, pk);

          con.commit();
          deleteIndex(pk);
        }
      } catch (Exception e) {
        rollback(con, e);
      } finally {
        closeConnection(con);
      }
    }
  }

  public Card getCard(long id) throws WhitePagesException {
    Card result;
    IdPK pk = new IdPK();
    try {
      SilverpeasBeanDAO<Card> dao = getCardDAO();
      pk.setIdAsLong(id);
      result = dao.findByPrimaryKey(pk);
    } catch (PersistenceException e) {
      throw new WhitePagesException(e);
    }
    return result;
  }

  public Collection<Card> getCards(String instanceId) throws WhitePagesException {
    return getCardsByCondition(BeanCriteria.addCriterion(INSTANCE_ID, instanceId));
  }

  private Collection<Card> getCardsByCondition(BeanCriteria criteria) throws WhitePagesException {
    Collection<Card> cards;
    try {
      SilverpeasBeanDAO<Card> dao = getCardDAO();
      cards = dao.findBy(criteria);
    } catch (PersistenceException e) {
      throw new WhitePagesException(e);
    }
    return cards;
  }

  @SuppressWarnings("DuplicatedCode")
  public Collection<Card> getCardsByIds(List<String> ids) throws WhitePagesException {
    Collection<Card> cards;
    try {
      BeanCriteria criteria = ids.isEmpty() ? BeanCriteria.emptyCriteria() :
          BeanCriteria.addCriterion("id",
              ids.stream().map(Integer::parseInt).collect(Collectors.toSet()));
      SilverpeasBeanDAO<Card> dao = getCardDAO();
      cards = dao.findBy(criteria);
    } catch (PersistenceException e) {
      throw new WhitePagesException(e);
    }
    return cards;
  }

  public Collection<Card> getVisibleCards(String instanceId) throws WhitePagesException {
    return getCardsByCondition(BeanCriteria.addCriterion(INSTANCE_ID, instanceId)
        .and(HIDE_STATUS, 0));
  }

  public List<WhitePagesCard> getUserCards(String userId, Collection<String> instanceIds)
      throws WhitePagesException {
    BeanCriteria criteria = BeanCriteria.addCriterion(USER_ID, userId)
        .and(HIDE_STATUS, 0);
    if (instanceIds != null && !instanceIds.isEmpty()) {
      criteria.and(INSTANCE_ID, instanceIds);
      return getWhitePagesCards(criteria);
    }
    return new ArrayList<>();
  }

  public List<WhitePagesCard> getHomeUserCards(String userId, Collection<String> instanceIds,
      String instanceId) throws WhitePagesException {
    BeanCriteria criteria = BeanCriteria.addCriterion(USER_ID, userId)
        .and(BeanCriteria.addCriterion(INSTANCE_ID, instanceId).or(HIDE_STATUS, 0));
    if (instanceIds != null && !instanceIds.isEmpty()) {
      criteria.and(INSTANCE_ID, instanceIds);
      return getWhitePagesCards(criteria);
    }
    return new ArrayList<>();
  }

  private List<WhitePagesCard> getWhitePagesCards(BeanCriteria criteria)
      throws WhitePagesException {
    List<WhitePagesCard> wpCards = new ArrayList<>();
    try {
      SilverpeasBeanDAO<Card> dao = getCardDAO();
      Collection<Card> cards = dao.findBy(criteria);
      if (cards != null) {
        for (Card card : cards) {
          wpCards
              .add(new WhitePagesCard(Long.parseLong(card.getPK().getId()), card.getInstanceId()));
        }
      }
    } catch (PersistenceException e) {
      throw new WhitePagesException(e);
    }
    return wpCards;
  }

  public void setHideStatus(Collection<String> ids, int status) throws WhitePagesException {
    if (ids != null) {
      try {
        SilverpeasBeanDAO<Card> dao = getCardDAO();
        for (String sId : ids) {
          long id = Long.parseLong(sId);
          IdPK pk = new IdPK();
          pk.setIdAsLong(id);
          Card card = dao.findByPrimaryKey(pk);
          card.setHideStatus(status);
          dao.update(card);

          card.getPK().setComponentName(card.getInstanceId());
          getWhitePagesContentManager().updateSilverContentVisibility(card);
        }
      } catch (Exception e) {
        throw new WhitePagesException(e);
      }
    }
  }

  public void reverseHide(Collection<String> ids) throws WhitePagesException {
    if (ids != null) {
      try {
        SilverpeasBeanDAO<Card> dao = getCardDAO();
        for (String sId : ids) {
          long id = Long.parseLong(sId);
          IdPK pk = new IdPK();
          pk.setIdAsLong(id);
          Card card = dao.findByPrimaryKey(pk);
          int status = card.getHideStatus();
          if (status == 0) {
            status = 1;
          } else {
            status = 0;
          }
          card.setHideStatus(status);
          dao.update(card);

          card.getPK().setComponentName(card.getInstanceId());
          getWhitePagesContentManager().updateSilverContentVisibility(card);
        }
      } catch (Exception e) {
        throw new WhitePagesException(e);
      }
    }
  }

  public boolean existCard(String userId, String instanceId) throws WhitePagesException {
    boolean exist = false;
    try {
      BeanCriteria criteria = BeanCriteria.addCriterion(INSTANCE_ID, instanceId)
          .and(USER_ID, userId);
      SilverpeasBeanDAO<Card> dao = getCardDAO();
      Collection<Card> cards = dao.findBy(criteria);
      if (cards != null && !cards.isEmpty()) {
        exist = true;
      }
    } catch (PersistenceException e) {
      throw new WhitePagesException(e);
    }
    return exist;
  }

  public boolean isPublicationClassifiedOnPDC(Card card)
      throws ContentManagerException, PdcException {
    ContentManagementEngine contentMgtEngine = ContentManagementEngineProvider.getContentManagementEngine();
    int contentId = contentMgtEngine.getSilverContentId(card.getPK().getId(), card.getInstanceId());
    PdcManager pdcManager = PdcManager.get();

    List<ClassifyPosition> positions = pdcManager.getPositions(contentId, card.getInstanceId());
    return !positions.isEmpty();
  }

  /**
   * Get card for a user and instance.
   * @param userId user id
   * @param instanceId instance id
   * @return the card, null if not found
   * @throws WhitePagesException if an error occurs
   */
  public Card getUserCard(String userId, String instanceId) throws WhitePagesException {
    Card card = null;
    try {
      SilverpeasBeanDAO<Card> dao = getCardDAO();
      BeanCriteria criteria = BeanCriteria.addCriterion(INSTANCE_ID, instanceId)
          .and(USER_ID, userId);
      Collection<Card> cards = dao.findBy(criteria);
      if (cards != null && !cards.isEmpty()) {
        card = cards.iterator().next();
      }
    } catch (PersistenceException e) {
      throw new WhitePagesException(e);
    }
    return card;
  }

  public void indexCard(Card card) {
    WAPrimaryKey pk = card.getPK();
    String userName = extractUserName(card);
    String userMail = extractUserMail(card);

    FullIndexEntry indexEntry = new FullIndexEntry(new IndexEntryKey(card.getInstanceId(), "card"
        , pk.getId()));
    indexEntry.setTitle(userName);
    indexEntry.setKeywords(userName);
    indexEntry.setPreview(userMail);
    try {
      indexEntry.setCreationDate(DateUtil.parse(card.getCreationDate()));
    } catch (ParseException e) {
      SilverLogger.getLogger(this).warn(e);
    }
    indexEntry.setCreationUser(Integer.toString(card.getCreatorId()));

    try {
      PublicationTemplate pub =
          PublicationTemplateManager.getInstance().getPublicationTemplate(card.getInstanceId());

      final String xmlFormShortName = pub.getFileName()
          .substring(pub.getFileName().indexOf("/") + 1, pub.getFileName().indexOf("."));

      RecordSet set = pub.getRecordSet();
      set.indexRecord(pk.getId(), xmlFormShortName, indexEntry);
    } catch (Exception e) {
      SilverLogger.getLogger(this).error("User card indexation failure", e);
    }

    IndexEngineProxy.addIndexEntry(indexEntry);
  }

  private void deleteIndex(WAPrimaryKey pk) {
    IndexEngineProxy.removeIndexEntry(new IndexEntryKey(pk.getComponentName(), "card", pk.getId()));
  }

  private String extractUserName(Card card) {
    StringBuilder text = new StringBuilder();

    UserRecord user = card.readUserRecord();
    Field f;

    if (user != null) {
      try {
        f = user.getField("FirstName");
        text.append(f.getStringValue());
        text.append(" ");
      } catch (FormException e) {
        SilverLogger.getLogger(this).warn(e);
      }

      try {
        f = user.getField("LastName");
        text.append(f.getStringValue());
      } catch (FormException e) {
        SilverLogger.getLogger(this).warn(e);
      }
    }
    return text.toString();
  }

  private String extractUserMail(Card card) {
    StringBuilder text = new StringBuilder();
    UserRecord record = card.readUserRecord();
    if (record != null) {
      User user = record.getUserDetail();
      if (user instanceof UserDetail && ((UserDetail) user).hasSensitiveData()) {
        return text.toString();
      }
      try {
        Field f = record.getField("Mail");
        text.append(f.getStringValue());
      } catch (FormException e) {
        SilverLogger.getLogger(this).warn(e);
      }
    }

    return text.toString();
  }

  private void rollback(Connection con, Exception e) throws WhitePagesException {
    try {
      con.rollback();
    } catch (Exception e1) {
      throw new WhitePagesException(e1);
    }

    throw new WhitePagesException(e);
  }

  private void closeConnection(Connection con) throws WhitePagesException {
    if (con != null) {
      try {
        con.close();
      } catch (SQLException e) {
        throw new WhitePagesException(e);
      }
    }
  }

  private SilverpeasBeanDAO<Card> getCardDAO() throws PersistenceException {
    return SilverpeasBeanDAOFactory.getDAO(Card.class);
  }
}
