/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements. See the NOTICE file distributed with this
 * work for additional information regarding copyright ownership. The ASF
 * licenses this file to You under the Apache 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://www.apache.org/licenses/LICENSE-2.0
 *
 * 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.apache.sling.testing.clients;

import org.apache.commons.io.IOUtils;
import org.apache.http.*;
import org.apache.http.client.utils.URLEncodedUtils;
import org.apache.http.entity.StringEntity;
import org.apache.http.protocol.HttpContext;
import org.apache.http.protocol.HttpRequestHandler;
import org.codehaus.jackson.node.JsonNodeFactory;
import org.codehaus.jackson.node.ObjectNode;
import org.junit.ClassRule;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;

import static java.nio.charset.StandardCharsets.UTF_8;
import static org.apache.http.HttpStatus.SC_BAD_REQUEST;
import static org.apache.http.HttpStatus.SC_CREATED;

public class SlingClientImportContentTest {
    private static final Logger LOG = LoggerFactory.getLogger(SlingClientImportContentTest.class);

    private static final String IMPORT_PATH = "/test/import/parent";
    private static final String IMPORT_FILE_PATH = "/content/importfile";

    private static final String IMPORT_FILE_CONTENT = "{\"nodefromfile\":{\"prop1\":\"val1\"}}";

    @ClassRule
    public static HttpServerRule httpServer = new HttpServerRule() {
        @Override
        protected void registerHandlers() throws IOException {
            serverBootstrap.registerHandler(IMPORT_PATH, new HttpRequestHandler() {
                @Override
                public void handle(HttpRequest request, HttpResponse response, HttpContext context) throws HttpException, IOException {
                    List<NameValuePair> params = extractParameters(request);
                    String operation = getParameter(":operation", params);
                    String content = getParameter(":content", params);

                    if (!"import".equals(operation)) {
                        response.setStatusCode(SC_BAD_REQUEST);
                        response.setEntity(new StringEntity("Unexpected operation: " + operation));
                        return;
                    }

                    if (!"{\"something\":{\"prop1\":\"val1\"}}".equals(content)) {
                        response.setStatusCode(SC_BAD_REQUEST);
                        response.setEntity(new StringEntity("Unexpected content: " + content));
                        return;
                    }

                    response.setStatusCode(SC_CREATED);
                }
            });

            serverBootstrap.registerHandler(IMPORT_FILE_PATH, new HttpRequestHandler() {
                @Override
                public void handle(HttpRequest request, HttpResponse response, HttpContext context) throws HttpException, IOException {
                    LOG.debug("received: {}", request);
                    if (request instanceof HttpEntityEnclosingRequest) {
                        HttpEntity entity = ((HttpEntityEnclosingRequest) request).getEntity();
                        String content = IOUtils.toString(entity.getContent(), UTF_8);
                        LOG.debug("content: {}", content);

                        if (!content.contains(":operation") || !content.contains("import")) {
                            response.setStatusCode(SC_BAD_REQUEST);
                            response.setEntity(new StringEntity("Operation not found"));
                            return;
                        } else if (!content.contains(IMPORT_FILE_CONTENT)) {
                            response.setStatusCode(SC_BAD_REQUEST);
                            response.setEntity(new StringEntity("File content not found"));
                            return;
                        }

                        response.setStatusCode(SC_CREATED);
                    } else {
                        response.setStatusCode(SC_BAD_REQUEST);
                        response.setEntity(new StringEntity("Request doesn't contain an entity"));
                    }
                }
            });
        }

        private List<NameValuePair> extractParameters(HttpRequest request) {
            if (request instanceof HttpEntityEnclosingRequest) {
                HttpEntity entity = ((HttpEntityEnclosingRequest) request).getEntity();
                try {
                    return URLEncodedUtils.parse(entity);
                } catch (IOException e) {
                    LOG.error("Failed to parse entity", e);
                }
            }

            return new ArrayList<>();
        }

        private String getParameter(String parameterName, List<NameValuePair> parameters) {
            for (NameValuePair parameter : parameters) {
                if (parameter.getName().equals(parameterName)) {
                    return parameter.getValue();
                }
            }

            return null;
        }
    };


    private SlingClient client;

    public SlingClientImportContentTest() throws ClientException {
        client = new SlingClient(httpServer.getURI(), "user", "pass");
        // to use with an already running instance
        // client = new SlingClient(java.net.URI.create("http://localhost:8080"), "admin", "admin");
    }

    @Test
    public void testImportContent() throws Exception {
        client.importContent(IMPORT_PATH, "json", "{\"something\":{\"prop1\":\"val1\"}}");
    }

    @Test
    public void testImportJson() throws Exception {
        ObjectNode node = JsonNodeFactory.instance.objectNode();
        ObjectNode props = JsonNodeFactory.instance.objectNode();
        props.put("prop1", "val1");

        node.put("something", props);
        client.importJson(IMPORT_PATH, node);
    }
    @Test
    public void testImportContentFile() throws Exception {
        File tmp = File.createTempFile("import-json", null);
        LOG.debug("created: " + tmp);
        PrintWriter pw = new PrintWriter(tmp);
        pw.write(IMPORT_FILE_CONTENT);
        pw.close();

        client.importContent(IMPORT_FILE_PATH, "json", tmp);
    }
}