/*
 * 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.meecrowave.proxy.servlet;

import static java.util.Arrays.asList;
import static java.util.Optional.ofNullable;
import static javax.ws.rs.client.Entity.entity;
import static javax.ws.rs.core.MediaType.APPLICATION_JSON;
import static javax.ws.rs.core.MediaType.MULTIPART_FORM_DATA;
import static javax.ws.rs.core.MediaType.TEXT_PLAIN_TYPE;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;

import java.io.IOException;
import java.net.HttpURLConnection;
import java.nio.charset.StandardCharsets;
import java.util.function.Consumer;

import javax.ws.rs.client.Client;
import javax.ws.rs.client.ClientBuilder;
import javax.ws.rs.client.WebTarget;
import javax.ws.rs.core.Response;

import org.apache.cxf.jaxrs.ext.multipart.Attachment;
import org.apache.cxf.jaxrs.ext.multipart.ContentDisposition;
import org.apache.cxf.jaxrs.ext.multipart.MultipartBody;
import org.apache.meecrowave.Meecrowave;
import org.apache.meecrowave.io.IO;
import org.apache.meecrowave.junit.MeecrowaveRule;
import org.apache.meecrowave.proxy.servlet.mock.FakeRemoteServer;
import org.junit.ClassRule;
import org.junit.Test;
import org.junit.rules.TestRule;

public class ProxyServletTest {
    @ClassRule(order = 1)
    public static final TestRule FAKE_REMOTE_SERVER = new FakeRemoteServer()
            .with((server, helper) -> server.createContext("/simple", exchange -> {
                final byte[] out = ("{\"message\":\"" + ofNullable(exchange.getRequestBody()).map(it -> {
                    try {
                        return IO.toString(it);
                    } catch (final IOException e) {
                        throw new IllegalStateException(e);
                    }
                }).orElse("ok") + "\"}").getBytes(StandardCharsets.UTF_8);
                exchange.getResponseHeaders().add("Fake-Server", "true");
                exchange.getResponseHeaders().add("Foo", ofNullable(exchange.getRequestURI().getQuery()).orElse("-"));
                helper.response(exchange, HttpURLConnection.HTTP_OK, out);
            }))
            .with((server, helper) -> server.createContext("/data1", exchange -> {
                final byte[] out = ("{\"message\":\"" + IO.toString(exchange.getRequestBody()) + "\"}")
                        .getBytes(StandardCharsets.UTF_8);
                exchange.getResponseHeaders().add("Fake-Server", "posted");
                helper.response(exchange, HttpURLConnection.HTTP_OK, out);
            }))
            .with((server, helper) -> server.createContext("/upload1", exchange -> {
                final byte[] out = ("{\"message\":\"" + IO.toString(exchange.getRequestBody()) + "\"}")
                        .getBytes(StandardCharsets.UTF_8);
                helper.response(exchange, HttpURLConnection.HTTP_OK, out);
            }));

    @ClassRule(order = 2)
    public static final MeecrowaveRule MW = new MeecrowaveRule(new Meecrowave.Builder().randomHttpPort()
            .property("proxy-configuration", "target/test-classes/routes.json"), "");

    @Test
    public void upload() {
        withClient(target -> {
            final Response response = target.path("/upload1").request()
                    .post(entity(new MultipartBody(asList(
                            new Attachment("metadata", APPLICATION_JSON, "{\"content\":\"text\"}"),
                            new Attachment(
                                    "file",
                                    Thread.currentThread().getContextClassLoader().getResourceAsStream("ProxyServletTest/upload/file.txt"),
                                    new ContentDisposition("uploadded.txt"))
                    )), MULTIPART_FORM_DATA));
            assertEquals(HttpURLConnection.HTTP_OK, response.getStatus());
            final String actual = response.readEntity(String.class);
            assertTrue(actual, actual.contains("uuid:"));
            assertTrue(actual, actual.contains("Content-Type: application/json"));
            assertTrue(actual, actual.contains("{\"content\":\"text\"}"));
            assertTrue(actual, actual.contains("Content-Type: application/octet-stream"));
            assertTrue(actual, actual.contains("test\nfile\nwith\nmultiple\nlines"));
        });
    }

    @Test
    public void get() {
        withClient(target -> {
            final Response response = target.path("/simple").request().get();
            assertEquals(HttpURLConnection.HTTP_OK, response.getStatus());
            assertEquals("true", response.getHeaderString("Fake-Server"));
            assertEquals("{\"message\":\"\"}", response.readEntity(String.class));
        });
    }

    @Test
    public void getWithQuery() {
        withClient(target -> {
            final Response response = target.path("/simple").queryParam("foo", "bar").request().get();
            assertEquals(HttpURLConnection.HTTP_OK, response.getStatus());
            assertEquals("foo=bar", response.getHeaderString("Foo"));
            assertEquals("{\"message\":\"\"}", response.readEntity(String.class));
        });
    }

    @Test
    public void post() {
        withClient(target -> {
            final Response response = target.path("/data1").request().post(entity("data were sent", TEXT_PLAIN_TYPE));
            assertEquals(HttpURLConnection.HTTP_OK, response.getStatus());
            assertEquals("posted", response.getHeaderString("Fake-Server"));
            assertEquals("{\"message\":\"data were sent\"}", response.readEntity(String.class));
        });
    }

    private void withClient(final Consumer<WebTarget> withBase) {
        final Client client = ClientBuilder.newClient();
        try {
            withBase.accept(client.target("http://localhost:" + MW.getConfiguration().getHttpPort()));
        } finally {
            client.close();
        }
    }
}