/*
    * 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.userdirectory.moodle;
  
  import org.apache.http.NameValuePair;
  import org.apache.http.client.methods.CloseableHttpResponse;
  import org.apache.http.client.methods.HttpGet;
  import org.apache.http.client.utils.URIBuilder;
  import org.apache.http.impl.client.CloseableHttpClient;
  import org.apache.http.impl.client.HttpClients;
  import org.apache.http.message.BasicNameValuePair;
  import org.json.simple.JSONArray;
  import org.json.simple.JSONObject;
  import org.json.simple.parser.JSONParser;
  import org.json.simple.parser.ParseException;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStreamReader;
  import java.net.URI;
  import java.net.URISyntaxException;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.LinkedList;
  import java.util.List;
  
  /**
   * Implementation of the Moodle web service client.
   */
  public class MoodleWebServiceImpl implements MoodleWebService {
    /**
     * The logger.
     */
    private static final Logger logger = LoggerFactory.getLogger(MoodleUserProviderInstance.class);
  
    /**
     * HTTP user agent when performing requests.
     */
    private static final String OC_USERAGENT = "Opencast";
  
    /**
     * The URL of the Moodle instance.
     */
    private URI url;
  
    /**
     * The token used to call Moodle REST webservices.
     */
    private String token;
  
    /**
     * Constructs a new Moodle web service client.
     *
     * @param url   URL of the Moodle instance
     * @param token Web service token
     */
    public MoodleWebServiceImpl(URI url, String token) {
      this.url = url;
      this.token = token;
    }
  
    /**
     * {@inheritDoc}
     */
    @Override
    public List<MoodleUser> coreUserGetUsersByField(CoreUserGetUserByFieldFilters filter, List<String> values)
            throws URISyntaxException, IOException, MoodleWebServiceException, ParseException {
      logger.debug("coreUserGetUsersByField(({}, {}))", filter, values);
  
      List<NameValuePair> params = new ArrayList<>();
      params.add(new BasicNameValuePair("field", filter.toString()));
  
      for (int i = 0; i < values.size(); ++i) {
        params.add(new BasicNameValuePair("values[" + i + "]", values.get(i)));
      }
  
      Object resp = executeMoodleRequest(MOODLE_FUNCTION_CORE_USER_GET_USERS_BY_FIELD, params);
  
     // Parse response
     if (resp == null || !(resp instanceof JSONArray)) {
       throw new MoodleWebServiceException("Moodle responded in unexpected format");
     }
 
     JSONArray respArray = (JSONArray) resp;
     List<MoodleUser> users = new ArrayList<>(respArray.size());
 
     for (Object userObj : respArray) {
       if (!(userObj instanceof JSONObject)) {
         throw new MoodleWebServiceException("Moodle responded in unexpected format");
       }
 
       JSONObject userJsonObj = (JSONObject) userObj;
       MoodleUser user = new MoodleUser();
 
       if (userJsonObj.containsKey("id")) {
         user.setId(userJsonObj.get("id").toString());
       }
       if (userJsonObj.containsKey("username")) {
         user.setUsername(userJsonObj.get("username").toString());
       }
       if (userJsonObj.containsKey("fullname")) {
         user.setFullname(userJsonObj.get("fullname").toString());
       }
       if (userJsonObj.containsKey("idnumber")) {
         user.setIdnumber(userJsonObj.get("idnumber").toString());
       }
       if (userJsonObj.containsKey("email")) {
         user.setEmail(userJsonObj.get("email").toString());
       }
       if (userJsonObj.containsKey("auth")) {
         user.setAuth(userJsonObj.get("auth").toString());
       }
 
       users.add(user);
     }
 
     return users;
   }
 
   /**
    * {@inheritDoc}
    *
    * @see org.opencastproject.userdirectory.moodle.MoodleWebService#toolOpencastGetCoursesForInstructor(String)
    */
   @Override
   public List<String> toolOpencastGetCoursesForInstructor(String username)
           throws URISyntaxException, IOException, MoodleWebServiceException, ParseException {
     logger.debug("toolOpencastGetCoursesForInstructor({})", username);
 
     List<NameValuePair> params = Collections
             .singletonList((NameValuePair) new BasicNameValuePair("username", username));
 
     return parseIdList(executeMoodleRequest(MOODLE_FUNCTION_TOOL_OPENCAST_GET_COURSES_FOR_INSTRUCTOR, params));
   }
 
   /**
    * {@inheritDoc}
    *
    * @see org.opencastproject.userdirectory.moodle.MoodleWebService#toolOpencastGetCoursesForLearner(String)
    */
   @Override
   public List<String> toolOpencastGetCoursesForLearner(String username)
           throws URISyntaxException, IOException, MoodleWebServiceException, ParseException {
     logger.debug("toolOpencastGetCoursesForLearner({})", username);
 
     List<NameValuePair> params = Collections
             .singletonList((NameValuePair) new BasicNameValuePair("username", username));
 
     return parseIdList(executeMoodleRequest(MOODLE_FUNCTION_TOOL_OPENCAST_GET_COURSES_FOR_LEARNER, params));
   }
 
   @Override
   public List<String> toolOpencastGetGroupsForLearner(String username)
           throws URISyntaxException, IOException, MoodleWebServiceException, ParseException {
     logger.debug("toolOpencastGetGroupsForLearner({})", username);
 
     List<NameValuePair> params = Collections
             .singletonList((NameValuePair) new BasicNameValuePair("username", username));
 
     return parseIdList(executeMoodleRequest(MOODLE_FUNCTION_TOOL_OPENCAST_GET_GROUPS_FOR_LEARNER, params));
   }
 
   /**
    * {@inheritDoc}
    *
    * @see org.opencastproject.userdirectory.moodle.MoodleWebService#getURL()
    */
   @Override
   public String getURL() {
     return url.toString();
   }
 
   /**
    * Parses the returned Moodle response for a list of IDs.
    *
    * @param resp The Moodle response. It should be of type {@link JSONArray}.
    * @return A list of Moodle IDs.
    * @throws MoodleWebServiceException If the parsing failed because the response format was unexpected.
    */
   private List<String> parseIdList(Object resp) throws MoodleWebServiceException {
     if (resp == null) {
       return new LinkedList<>();
     }
 
     if (!(resp instanceof JSONArray)) {
       throw new MoodleWebServiceException("Moodle responded in unexpected format");
     }
 
     JSONArray respArray = (JSONArray) resp;
     List<String> ids = new ArrayList<>(respArray.size());
 
     for (Object courseObj : respArray) {
       if (!(courseObj instanceof JSONObject) || ((JSONObject) courseObj).get("id") == null) {
         throw new MoodleWebServiceException("Moodle responded in unexpected format");
       }
 
       ids.add(((JSONObject) courseObj).get("id").toString());
     }
 
     return ids;
   }
 
   /**
    * Executes a Moodle webservice request.
    *
    * @param function The function to execute.
    * @param params   Additional parameters to pass.
    * @return A JSON object, array, String, Number, Boolean, or null.
    * @throws URISyntaxException        In case the URL cannot be constructed.
    * @throws IOException               In case of an IO error.
    * @throws MoodleWebServiceException In case Moodle returns an error.
    * @throws ParseException            In case the Moodle response cannot be parsed.
    */
   private Object executeMoodleRequest(String function, List<NameValuePair> params)
           throws URISyntaxException, IOException, MoodleWebServiceException, ParseException {
     // Build URL
     URIBuilder url = new URIBuilder(this.url);
     url.addParameters(params);
     url.addParameter("wstoken", token);
     url.addParameter("wsfunction", function);
     url.addParameter("moodlewsrestformat", "json");
 
     // Execute request
     HttpGet get = new HttpGet(url.build());
     get.setHeader("User-Agent", OC_USERAGENT);
 
     try (CloseableHttpClient client = HttpClients.createDefault()) {
       try (CloseableHttpResponse resp = client.execute(get)) {
         // Parse response
         BufferedReader reader = new BufferedReader(new InputStreamReader(resp.getEntity().getContent()));
         JSONParser parser = new JSONParser();
         Object obj = parser.parse(reader);
 
         // Check for errors
         if (obj instanceof JSONObject) {
           JSONObject jObj = (JSONObject) obj;
           if (jObj.containsKey("exception") || jObj.containsKey("errorcode")) {
             throw new MoodleWebServiceException("Moodle returned an error: " + jObj.toJSONString());
           }
         }
 
         return obj;
       }
     }
   }
 }