package jalview.ws.dbsources;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import jalview.ws.dbsources.PDBRestClient.PDBDocField;
import jalview.ws.uimodel.PDBRestRequest;
import jalview.ws.uimodel.PDBRestResponse;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import javax.ws.rs.core.MediaType;

import org.json.simple.JSONArray;
import org.json.simple.JSONObject;
import org.json.simple.parser.JSONParser;
import org.json.simple.parser.ParseException;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.sun.jersey.api.client.Client;
import com.sun.jersey.api.client.ClientResponse;
import com.sun.jersey.api.client.WebResource;
import com.sun.jersey.api.client.config.ClientConfig;
import com.sun.jersey.api.client.config.DefaultClientConfig;

public class PDBRestClientTest
{

  @Before
  public void setUp() throws Exception
  {
  }

  @After
  public void tearDown() throws Exception
  {
  }

  @Test
  public void executeRequestTest()
  {
    List<PDBDocField> wantedFields = new ArrayList<PDBDocField>();
    wantedFields.add(PDBDocField.MOLECULE_TYPE);
    wantedFields.add(PDBDocField.PDB_ID);
    wantedFields.add(PDBDocField.GENUS);
    wantedFields.add(PDBDocField.GENE_NAME);
    wantedFields.add(PDBDocField.TITLE);

    PDBRestRequest request = new PDBRestRequest();
    request.setAllowEmptySeq(false);
    request.setResponseSize(100);
    request.setFieldToSearchBy("text:");
    request.setSearchTerm("abc");
    request.setWantedFields(wantedFields);

    PDBRestResponse response = new PDBRestClient().executeRequest(request);
    assertTrue(response.getNumberOfItemsFound() > 99);
    assertTrue(response.getSearchSummary() != null);
    assertTrue(response.getSearchSummary().size() > 99);
  }

  @Test
  public void getPDBDocFieldsAsCommaDelimitedStringTest()
  {
    List<PDBDocField> wantedFields = new ArrayList<PDBDocField>();
    wantedFields.add(PDBDocField.MOLECULE_TYPE);
    wantedFields.add(PDBDocField.PDB_ID);
    wantedFields.add(PDBDocField.GENUS);
    wantedFields.add(PDBDocField.GENE_NAME);
    wantedFields.add(PDBDocField.TITLE);

    String expectedResult = "molecule_type,pdb_id,genus,gene_name,title";
    String actualResult = PDBRestClient
            .getPDBDocFieldsAsCommaDelimitedString(wantedFields);

    assertEquals("", expectedResult, actualResult);
  }

  @Test
  public void parsePDBJsonExceptionStringTest()
  {
    List<PDBDocField> wantedFields = new ArrayList<PDBDocField>();
    wantedFields.add(PDBDocField.MOLECULE_TYPE);
    wantedFields.add(PDBDocField.PDB_ID);
    wantedFields.add(PDBDocField.GENUS);
    wantedFields.add(PDBDocField.GENE_NAME);
    wantedFields.add(PDBDocField.TITLE);

    PDBRestRequest request = new PDBRestRequest();
    request.setAllowEmptySeq(false);
    request.setResponseSize(100);
    request.setFieldToSearchBy("text:");
    request.setSearchTerm("abc");
    request.setWantedFields(wantedFields);

    String jsonErrorResponse = "";
    try
    {
      jsonErrorResponse = readJsonStringFromFile("test/jalview/io/pdb_request_json_error.txt");
    } catch (IOException e)
    {
      e.printStackTrace();
    }

    String parsedErrorResponse = PDBRestClient
            .parseJsonExceptionString(jsonErrorResponse);

    String expectedErrorMsg = "\n============= PDB Rest Client RunTime error =============\n"
            + "Status: 400\n"
            + "Message: org.apache.solr.search.SyntaxError: Cannot parse 'text:abc OR text:go:abc AND molecule_sequence:['' TO *]': Encountered \" \":\" \": \"\" at line 1, column 19.\n"
            + "query: text:abc OR text:go:abc AND molecule_sequence:['' TO *]\n"
            + "fl: pdb_id\n";

    assertEquals(expectedErrorMsg, parsedErrorResponse);
  }

  @Test(expected = RuntimeException.class)
  public void testForExpectedRuntimeException()
  {
    List<PDBDocField> wantedFields = new ArrayList<PDBDocField>();
    wantedFields.add(PDBDocField.PDB_ID);

    PDBRestRequest request = new PDBRestRequest();
    request.setFieldToSearchBy("text:");
    request.setSearchTerm("abc OR text:go:abc");
    request.setWantedFields(wantedFields);
    new PDBRestClient().executeRequest(request);
  }

  @Test
  public void parsePDBJsonResponseTest()
  {
    List<PDBDocField> wantedFields = new ArrayList<PDBDocField>();
    wantedFields.add(PDBDocField.MOLECULE_TYPE);
    wantedFields.add(PDBDocField.PDB_ID);
    wantedFields.add(PDBDocField.GENUS);
    wantedFields.add(PDBDocField.GENE_NAME);
    wantedFields.add(PDBDocField.TITLE);

    PDBRestRequest request = new PDBRestRequest();
    request.setAllowEmptySeq(false);
    request.setWantedFields(wantedFields);

    String jsonString = "";
    try
    {
      jsonString = readJsonStringFromFile("test/jalview/io/pdb_response_json.txt");
    } catch (IOException e)
    {
      e.printStackTrace();
    }
    PDBRestResponse response = PDBRestClient.parsePDBJsonResponse(
            jsonString, request);
    assertTrue(response.getSearchSummary() != null);
    assertTrue(response.getNumberOfItemsFound() == 931);
    assertTrue(response.getSearchSummary().size() == 14);
  }

  @Test
  public void getPDBIdColumIndexTest()
  {
    List<PDBDocField> wantedFields = new ArrayList<PDBDocField>();
    wantedFields.add(PDBDocField.MOLECULE_TYPE);
    wantedFields.add(PDBDocField.GENUS);
    wantedFields.add(PDBDocField.GENE_NAME);
    wantedFields.add(PDBDocField.TITLE);
    wantedFields.add(PDBDocField.PDB_ID);
    assertEquals(5, PDBRestClient.getPDBIdColumIndex(wantedFields, true));
    assertEquals(4, PDBRestClient.getPDBIdColumIndex(wantedFields, false));
  }

  @Test
  public void externalServiceIntegrationTest()
  {
    ClientConfig clientConfig = new DefaultClientConfig();
    Client client = Client.create(clientConfig);

    // Build request parameters for the REST Request
    WebResource webResource = client
            .resource(PDBRestClient.PDB_SEARCH_ENDPOINT)
            .queryParam("wt", "json").queryParam("rows", String.valueOf(1))
            .queryParam("q", "text:abc AND molecule_sequence:['' TO *]");

    // Execute the REST request
    ClientResponse clientResponse = webResource.accept(
            MediaType.APPLICATION_JSON).get(ClientResponse.class);

    // Get the JSON string from the response object
    String pdbJsonResponseString = clientResponse.getEntity(String.class);

    // Check the response status and report exception if one occurs
    if (clientResponse.getStatus() != 200)
    {
      fail("Webservice call failed!!!");
    }
    else
    {
      try
      {
        JSONParser jsonParser = new JSONParser();
        JSONObject jsonObj = (JSONObject) jsonParser
                .parse(pdbJsonResponseString);
        JSONObject pdbResponse = (JSONObject) jsonObj.get("response");
        String queryTime = ((JSONObject) jsonObj.get("responseHeader"))
                .get("QTime").toString();
        String numFound = pdbResponse.get("numFound").toString();
        JSONArray docs = (JSONArray) pdbResponse.get("docs");
        Iterator<JSONObject> docIter = docs.iterator();

        assertTrue("Couldn't Retrieve 'response' object",
                pdbResponse != null);
        assertTrue("Couldn't Retrieve 'QTime' value", queryTime != null);
        assertTrue("Couldn't Retrieve 'numFound' value", numFound != null);
        assertTrue("Couldn't Retrieve 'docs' object", docs != null
                || !docIter.hasNext());

        JSONObject pdbJsonDoc = docIter.next();

        for (PDBDocField field : PDBDocField.values())
        {
          if (field == PDBDocField.ALL)
          {
            continue;
          }
          if (pdbJsonDoc.get(field.getCode()) == null)
          {
            // System.out.println(">>>\t" + field.getCode());
            assertTrue(field.getClass()
                    + " has been removed from PDB doc Entity",
                    !pdbJsonResponseString.contains(field.getCode()));
          }
        }
      } catch (ParseException e)
      {
        fail(">>>  Test failed due to exception while parsing pdb response json !!!");
        e.printStackTrace();
      }
    }
  }

  public String readJsonStringFromFile(String filePath) throws IOException
  {
    String fileContent;
    BufferedReader br = new BufferedReader(new FileReader(filePath));
    try
    {
      StringBuilder sb = new StringBuilder();
      String line = br.readLine();

      while (line != null)
      {
        sb.append(line);
        sb.append(System.lineSeparator());
        line = br.readLine();
        }
      fileContent = sb.toString();
    } finally
    {
      br.close();
    }
    return fileContent;
  }

}