/*
    * Licensed to The Apereo Foundation under one or more contributor license
    * agreements. See the NOTICE file distributed with this work for additional
    * information regarding copyright ownership.
    *
    *
    * The Apereo Foundation licenses this file to you under the Educational
    * Community License, Version 2.0 (the "License"); you may not use this file
    * except in compliance with the License. You may obtain a copy of the License
   * at:
   *
   *   http://opensource.org/licenses/ecl2.txt
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
   * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
   * License for the specific language governing permissions and limitations under
   * the License.
   *
   */
  
  package org.opencastproject.search.api;
  
  import org.opencastproject.mediapackage.EName;
  import org.opencastproject.mediapackage.MediaPackage;
  import org.opencastproject.mediapackage.MediaPackageException;
  import org.opencastproject.mediapackage.MediaPackageParser;
  import org.opencastproject.metadata.dublincore.DublinCore;
  import org.opencastproject.metadata.dublincore.DublinCoreCatalog;
  import org.opencastproject.metadata.dublincore.DublinCoreValue;
  import org.opencastproject.metadata.dublincore.DublinCores;
  import org.opencastproject.metadata.dublincore.OpencastDctermsDublinCore;
  import org.opencastproject.security.api.AccessControlEntry;
  import org.opencastproject.security.api.AccessControlList;
  
  import com.google.gson.Gson;
  
  import org.elasticsearch.index.mapper.DateFieldMapper;
  
  import java.time.Instant;
  import java.time.ZoneOffset;
  import java.time.format.DateTimeFormatter;
  import java.util.Date;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import java.util.stream.Collectors;
  
  public class SearchResult {
  
    public static final String TYPE = "type";
    public static final String MEDIAPACKAGE = "mediapackage";
    public static final String MEDIAPACKAGE_XML = "mediapackage_xml";
    public static final String DUBLINCORE = "dc";
    public static final String ORG = "org";
    public static final String MODIFIED_DATE = "modified";
    public static final String DELETED_DATE = "deleted";
    public static final String INDEX_ACL = "searchable_acl";
    public static final String REST_ACL = "acl";
    public static final String LIVE = "live";
  
    private static final Gson gson = new Gson();
  
    private SearchService.IndexEntryType type;
  
    private MediaPackage mp;
  
    private DublinCoreCatalog dublinCore;
  
    private AccessControlList acl;
  
    private String orgId;
  
    private String id = null;
  
    private Boolean live = null;
  
    private Instant modified = null;
  
    private Instant deleted = null;
  
    public SearchResult(SearchService.IndexEntryType type, DublinCoreCatalog dc, AccessControlList acl,
            String orgId, MediaPackage mp, Instant modified, Instant deleted) {
      this.type = type;
      this.dublinCore = dc;
      this.acl = acl;
      this.orgId = orgId;
      this.mp = mp;
      this.deleted = deleted;
      this.modified = modified;
  
      if (SearchService.IndexEntryType.Episode.equals(type)) {
        this.id = this.getMediaPackage().getIdentifier().toString();
        this.live = this.getMediaPackage().isLive();
      } else if (SearchService.IndexEntryType.Series.equals(type)) {
        this.id = this.dublinCore.getFirst(DublinCore.PROPERTY_IDENTIFIER);
     }
   }
 
   public Date getModifiedDate() {
     return new Date(this.modified.toEpochMilli());
   }
 
   public String getId() {
     return this.id;
   }
 
   public Boolean getLive() {
     return this.live;
   }
 
   public Date getDeletionDate() {
     return null == this.deleted ? null : new Date(this.deleted.toEpochMilli());
   }
 
   @SuppressWarnings("unchecked")
   public static SearchResult rehydrate(Map<String, Object> data) throws SearchException {
     //Our sole parameter here is a map containing a mix of string:string pairs, and String:Map<String, Object> pairs
 
     try {
       // We're *really* hoping that no one feeds us things that aren't what we expect
       // but ES results come back in json, and get turned into multi-layered Maps
       SearchService.IndexEntryType type = SearchService.IndexEntryType.valueOf((String) data.get(TYPE));
       DublinCoreCatalog dc = rehydrateDC(type, (Map<String, Object>) data.get(DUBLINCORE));
       AccessControlList acl = rehydrateACL((Map<String, Object>) data.get(INDEX_ACL));
       String org = (String) data.get(ORG);
 
       Instant deleted = null;
       if (data.containsKey(DELETED_DATE) && null != data.get(DELETED_DATE)) {
         deleted = Instant.parse((String) data.get(DELETED_DATE));
       }
 
       Instant modified = null;
       if (data.containsKey(MODIFIED_DATE) && !data.get(MODIFIED_DATE).equals("null")) {
         modified = Instant.parse((String) data.get(MODIFIED_DATE));
       }
 
 
       MediaPackage mp = null;
       //There had better be a mediapackage with an episode...
       if (SearchService.IndexEntryType.Episode.equals(type)) {
         mp = MediaPackageParser.getFromXml((String) data.get(MEDIAPACKAGE_XML));
       }
       return new SearchResult(type, dc, acl, org, mp, modified, deleted);
     } catch (MediaPackageException e) {
       throw new SearchException(e);
     }
   }
 
   public static Map<String, List<String>> dehydrateDC(DublinCoreCatalog dublinCoreCatalog) {
     var metadata = new HashMap<String, List<String>>();
     for (var entry : dublinCoreCatalog.getValues().entrySet()) {
       var key = entry.getKey().getLocalName();
       var values = entry.getValue().stream()
               .map(DublinCoreValue::getValue)
               .map(val -> {
                 // Normalize `created` field: we want it to be in ISO 8601 format in UTC.
                 if (entry.getKey().equals(DublinCore.PROPERTY_CREATED)) {
                   var date = DateFieldMapper.DEFAULT_DATE_TIME_FORMATTER.parse(val);
                   return DateFieldMapper.DEFAULT_DATE_TIME_FORMATTER.withZone(ZoneOffset.UTC).format(date);
                 } else {
                   return val;
                 }
               })
               .collect(Collectors.toList());
       metadata.put(key, values);
     }
 
     return metadata;
   }
 
   /**
    * Simplify ACL structure, so we can easily search by action.
    * @param acl The access control List to restructure
    * @return Restructured ACL
    */
   public static Map<String, Set<String>> dehydrateAclForIndex(AccessControlList acl) {
     var result = new HashMap<String, Set<String>>();
     for (var entry : acl.getEntries()) {
       var action = entry.getAction();
       if (!result.containsKey(action)) {
         result.put(action, new HashSet<>());
       }
       result.get(action).add(entry.getRole());
     }
     return result;
   }
 
   public static List<Map<String, ?>> dehydrateAclForREST(AccessControlList acl) {
     return acl.getEntries().stream()
         .map(ace -> Map.of("action", ace.getAction(), "role", ace.getRole(), "allow", Boolean.TRUE))
         .collect(Collectors.toList());
   }
 
   @SuppressWarnings("unchecked")
   public static AccessControlList rehydrateACL(Map<String, Object> map) {
     List<AccessControlEntry> aces = new LinkedList<>();
     for (var entry : map.entrySet()) {
       String action = entry.getKey();
       for (String rolename : (List<String>)  entry.getValue()) {
         AccessControlEntry ace = new AccessControlEntry(rolename, action, true);
         aces.add(ace);
       }
     }
     return new AccessControlList(aces);
   }
 
   @SuppressWarnings("unchecked")
   public static DublinCoreCatalog rehydrateDC(SearchService.IndexEntryType type, Map<String, Object> map)
           throws SearchException {
     OpencastDctermsDublinCore dc;
     if (SearchService.IndexEntryType.Episode.equals(type)) {
       dc = DublinCores.mkOpencastEpisode();
     } else if (SearchService.IndexEntryType.Series.equals(type)) {
       dc = DublinCores.mkOpencastSeries();
     } else {
       throw new SearchException("Unknown DC type!");
     }
     for (var entry: map.entrySet()) {
       String key = entry.getKey();
       //This is *always* a list, per dehydrateACL
       List<String> value = (List<String>) entry.getValue();
       dc.set(EName.mk(DublinCore.TERMS_NS_URI, key), value);
     }
     return dc.getCatalog();
   }
 
   public Map<String, Object> dehydrateForIndex() {
     return dehydrate().entrySet().stream()
         .filter(entry -> !entry.getKey().equals(REST_ACL))
         .collect(HashMap::new, (m,v)->m.put(v.getKey(), v.getValue()), HashMap::putAll);
   }
 
   public Map<String, Object> dehydrateForREST() {
     return dehydrate().entrySet().stream()
         .filter(entry -> !entry.getKey().equals(INDEX_ACL))
         .filter(entry -> !entry.getKey().equals(MEDIAPACKAGE_XML))
         .collect(HashMap::new, (m,v)->m.put(v.getKey(), v.getValue()), HashMap::putAll);
   }
 
   public Map<String, Object> dehydrate() {
     if (SearchService.IndexEntryType.Episode.equals(getType())) {
       return dehydrateEpisode();
     } else if (SearchService.IndexEntryType.Series.equals(getType())) {
       return dehydrateSeries();
     }
     return null;
   }
 
   public Map<String, Object> dehydrateEpisode() {
 
     var ret = new HashMap<>(Map.of(
         MEDIAPACKAGE, gson.fromJson(MediaPackageParser.getAsJSON(this.mp), Map.class).get(MEDIAPACKAGE),
         MEDIAPACKAGE_XML, MediaPackageParser.getAsXml(this.mp),
         INDEX_ACL, SearchResult.dehydrateAclForIndex(acl),
         REST_ACL, SearchResult.dehydrateAclForREST(acl),
         DUBLINCORE, SearchResult.dehydrateDC(this.dublinCore),
         ORG, this.orgId,
         TYPE, this.type.name(),
         MODIFIED_DATE, DateTimeFormatter.ISO_INSTANT.format(this.modified),
         LIVE, this.live));
 
     ret.put(DELETED_DATE, null == this.deleted ? null : DateTimeFormatter.ISO_INSTANT.format(this.deleted));
 
     return ret;
   }
 
   public Map<String, Object> dehydrateSeries() {
 
     var ret = new HashMap<>(Map.of(
         INDEX_ACL, SearchResult.dehydrateAclForIndex(acl),
         REST_ACL, SearchResult.dehydrateAclForREST(acl),
         DUBLINCORE, SearchResult.dehydrateDC(this.dublinCore),
         ORG, this.orgId,
         TYPE, this.type.name(),
         MODIFIED_DATE, DateTimeFormatter.ISO_INSTANT.format(this.modified)));
 
     ret.put(DELETED_DATE, null == this.deleted ? null : DateTimeFormatter.ISO_INSTANT.format(this.deleted));
 
     return ret;
   }
 
   public DublinCoreCatalog getDublinCore() {
     return this.dublinCore;
   }
 
   public AccessControlList getAcl() {
     return acl;
   }
 
   public MediaPackage getMediaPackage() {
     return mp;
   }
 
   public SearchService.IndexEntryType getType() {
     return type;
   }
 
   public Instant getCreatedDate() {
     var acc = DateFieldMapper.DEFAULT_DATE_TIME_FORMATTER.parse(this.dublinCore.getFirst(DublinCore.PROPERTY_CREATED));
     return Instant.from(acc);
   }
 
   public String getOrgId() {
     return orgId;
   }
 }