package com.acumenvelocity.ath.solr;
   
   import java.io.Closeable;
   import java.io.IOException;
   import java.util.Iterator;
   import java.util.List;
   import java.util.Map;
   import java.util.stream.Collectors;
   
  import org.apache.solr.client.solrj.SolrClient;
  import org.apache.solr.client.solrj.SolrQuery;
  import org.apache.solr.client.solrj.SolrRequest.METHOD;
  import org.apache.solr.client.solrj.impl.HttpSolrClient;
  import org.apache.solr.client.solrj.request.SolrPing;
  import org.apache.solr.client.solrj.response.QueryResponse;
  import org.apache.solr.client.solrj.response.UpdateResponse;
  import org.apache.solr.common.SolrInputDocument;
  
  import com.acumenvelocity.ath.common.AthUtil;
  import com.acumenvelocity.ath.common.Const;
  import com.acumenvelocity.ath.common.Log;
  import com.acumenvelocity.ath.common.exception.AthException;
  
  import net.sf.okapi.common.Util;
  
  @SuppressWarnings("deprecation")
  public class Solr implements Closeable {
    public static final String REQUEST_HANDLER = "requestHandler";
    public static final String INCLUDE_SCORE = "includeScore";
    public static final String ROWS = "rows"; // max hits
    public static final String FIELDS = "fields";  
  
    private SolrClient solr;
  
    public Solr() {
      super();
      // solr = new Http2SolrClient.Builder(Const.ATH_SOLR_URL).build();
      solr = new HttpSolrClient.Builder(Const.ATH_SOLR_URL).build();
    }
  
    public void createOne(String coreName, Map<String, Object> doc)
        throws Exception {
      doCreateOne(coreName, doc);
      solr.commit(coreName, false, false, true);
    }
  
    public long createMany(String coreName, List<Map<String, Object>> docs)
        throws Exception {
      // for (Map<String, Object> doc : docs) {
      // doCreateOne(coreName, doc);
      // }
      if (Util.isEmpty(docs)) {
        Log.warn(this.getClass(), "Empty list of docs is passed to createMany() in {}", coreName);
        return 0;
      }
  
      int numDocs = docs.size();
      // Even if nulls were removed, it shouldn't decrease the number of created docs
      docs = AthUtil.removeNulls(docs);
  
      List<SolrInputDocument> solrDocs = docs.stream().map(doc -> {
        SolrInputDocument solrDoc = new SolrInputDocument();
        doc.forEach((name, value) -> solrDoc.addField(name, value));
        return solrDoc;
      }).collect(Collectors.toList());
  
      solr.add(coreName, solrDocs);
      solr.commit(coreName, false, false, true);
      return numDocs;
    }
  
    private void doCreateOne(String coreName, Map<String, Object> doc)
        throws AthException {
      SolrInputDocument document = new SolrInputDocument();
      doc.forEach((name, value) -> document.addField(name, value));
  
      try {
        solr.add(coreName, document);
  
      } catch (Exception e) {
        // PortalcatException.logAndThrow(this.getClass(), e,
        // "Error storing to solr\n\ndocument: {}\n\ndoc: {}", document, doc);
        Log.warn(this.getClass(),
            "Error storing to solr: {}\n\ndocument: {}\n\ndoc: {}",
            e.getMessage(), document,
            doc);
      }
    }
  
    public void deleteById(String coreName, String id) throws Exception {
      solr.deleteById(coreName, id);
      solr.commit(coreName, false, false, true);
    }
  
    public void deleteByIds(String coreName, List<String> ids) throws Exception {
      solr.deleteById(coreName, ids);
      solr.commit(coreName, false, false, true);
    }
  
   public void deleteByQuery(String coreName, String query) throws Exception {
     solr.deleteByQuery(coreName, query);
     solr.commit(coreName, false, false, true);
   }
 
   public void commit(String coreName) throws Exception {
     solr.commit(coreName, false, false, true);
   }
 
   public <Response> Response getMany(String coreName, String query, Map<String, Object> queryParams,
       Class<Response> responseClass) throws Exception {
 
     Log.trace(Solr.class, "--- getMany() query:'{}'", query);
     SolrQuery solrQuery = new SolrQuery();
     solrQuery.setQuery(query);
 
     if (queryParams != null) {
       queryParams.forEach((name, value) -> {
         switch (name) {
         case REQUEST_HANDLER:
           Object rhParam = queryParams.get(REQUEST_HANDLER);
           if (rhParam != null) {
             solrQuery.setRequestHandler(rhParam.toString());
           }
           break;
 
         case FIELDS:
           solrQuery.setFields((String[]) queryParams.get(FIELDS));
           break;
 
         case INCLUDE_SCORE:
           solrQuery.setIncludeScore((Boolean) queryParams.get(INCLUDE_SCORE));
           break;
 
         case ROWS:
           solrQuery.setRows((Integer) queryParams.get(ROWS));
           break;
 
         default:
           // Query parameters added by name
           if (value instanceof String[]) {
             solrQuery.setParam(name, (String[]) value);
 
           } else if (value instanceof Boolean) {
             solrQuery.setParam(name, (Boolean) value);
           }
           break;
         }
       });
     }
 
     // XXX solr.query(coreName, solrQuery) uses METHOD.GET and causes "URI Too Long", changed to
     // METHOD.POST
     // QueryResponse response = solr.query(coreName, solrQuery);
     QueryResponse response = solr.query(coreName, solrQuery, METHOD.POST);
     return responseClass.cast(response);
   }
 
   public void close() throws IOException {
     solr.close();
   }
 
   public void ping(String coreName) throws Exception {
     // solr.ping(coreName); // v. 8.7.0
     new SolrPing().process(solr, coreName); // v. 8.1.1
   }
 
   public long createMany(String coreName, Iterator<SolrInputDocument> solrDocs)
       throws Exception {
     solr.add(coreName, solrDocs);
     UpdateResponse response = solr.commit(coreName, false, false, true);
     return response.getResponse().size();
   }
 
   public SolrClient getClient() {
     return solr;
   }
 }