/*
 * 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.maven.wagon.providers.http;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.SeekableByteChannel;
import java.nio.file.Files;
import java.nio.file.OpenOption;
import java.nio.file.StandardOpenOption;

import org.apache.maven.wagon.Wagon;
import org.apache.maven.wagon.observers.Debug;
import org.apache.maven.wagon.repository.Repository;
import org.codehaus.plexus.PlexusTestCase;
import org.codehaus.plexus.util.IOUtil;
import org.eclipse.jetty.server.HttpConfiguration;
import org.eclipse.jetty.server.HttpConnectionFactory;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.ServerConnector;
import org.eclipse.jetty.servlet.ServletContextHandler;
import org.eclipse.jetty.servlet.ServletHolder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * @author Olivier Lamy
 */
public class HugeFileDownloadTest extends PlexusTestCase {

    private static final Logger LOGGER = LoggerFactory.getLogger(HugeFileDownloadTest.class);

    private static long HUGE_FILE_SIZE = Integer.valueOf(Integer.MAX_VALUE).longValue()
            + Integer.valueOf(Integer.MAX_VALUE).longValue();

    private Server server;
    private ServerConnector connector;

    public void testDownloadHugeFileWithContentLength() throws Exception {
        final File hugeFile = new File(getBasedir(), "target/hugefile.txt");
        if (!hugeFile.exists() || hugeFile.length() < HUGE_FILE_SIZE) {
            makeHugeFile(hugeFile);
        }

        server = new Server();
        connector = new ServerConnector(server, new HttpConnectionFactory(new HttpConfiguration()));
        server.addConnector(connector);

        ServletContextHandler root = new ServletContextHandler(ServletContextHandler.SESSIONS);
        root.setResourceBase(new File(getBasedir(), "target").getAbsolutePath());
        ServletHolder servletHolder = new ServletHolder(new HttpServlet() {
            @Override
            protected void doGet(HttpServletRequest req, HttpServletResponse resp)
                    throws ServletException, IOException {
                FileInputStream fis = new FileInputStream(hugeFile);

                resp.addHeader("Content-Length", String.valueOf(hugeFile.length()));
                IOUtil.copy(fis, resp.getOutputStream());
                fis.close();
            }
        });
        root.addServlet(servletHolder, "/*");
        server.setHandler(root);

        server.start();

        File dest = null;
        try {
            Wagon wagon = getWagon();
            wagon.connect(new Repository("id", "http://localhost:" + connector.getLocalPort()));

            dest = File.createTempFile("huge", "txt");

            LOGGER.info("Fetching 'hugefile.txt' with content length");
            wagon.get("hugefile.txt", dest);

            assertTrue(dest.length() >= HUGE_FILE_SIZE);
            LOGGER.info("The file was successfully fetched");

            wagon.disconnect();
        } finally {
            server.stop();
            dest.delete();
            hugeFile.delete();
        }
    }

    public void testDownloadHugeFileWithChunked() throws Exception {
        final File hugeFile = new File(getBasedir(), "target/hugefile.txt");
        if (!hugeFile.exists() || hugeFile.length() < HUGE_FILE_SIZE) {
            makeHugeFile(hugeFile);
        }

        server = new Server();
        connector = new ServerConnector(server, new HttpConnectionFactory(new HttpConfiguration()));
        server.addConnector(connector);

        ServletContextHandler root = new ServletContextHandler(ServletContextHandler.SESSIONS);
        root.setResourceBase(new File(getBasedir(), "target").getAbsolutePath());
        ServletHolder servletHolder = new ServletHolder(new HttpServlet() {
            @Override
            protected void doGet(HttpServletRequest req, HttpServletResponse resp)
                    throws ServletException, IOException {
                FileInputStream fis = new FileInputStream(hugeFile);

                IOUtil.copy(fis, resp.getOutputStream());
                fis.close();
            }
        });
        root.addServlet(servletHolder, "/*");
        server.setHandler(root);

        server.start();

        File dest = null;
        try {
            Wagon wagon = getWagon();
            wagon.connect(new Repository("id", "http://localhost:" + connector.getLocalPort()));

            dest = File.createTempFile("huge", "txt");

            LOGGER.info("Fetching 'hugefile.txt' in chunks");
            wagon.get("hugefile.txt", dest);

            assertTrue(dest.length() >= HUGE_FILE_SIZE);
            LOGGER.info("The file was successfully fetched");

            wagon.disconnect();
        } finally {
            server.stop();
            dest.delete();
            hugeFile.delete();
        }
    }

    protected Wagon getWagon() throws Exception {
        Wagon wagon = (Wagon) lookup(Wagon.ROLE, "http");

        Debug debug = new Debug();

        wagon.addSessionListener(debug);

        return wagon;
    }

    private void makeHugeFile(File hugeFile) throws Exception {
        LOGGER.info("Creating test file");
        final ByteBuffer buf = ByteBuffer.allocate(4).putInt(2);
        buf.rewind();

        final OpenOption[] options = {StandardOpenOption.WRITE, StandardOpenOption.CREATE_NEW, StandardOpenOption.SPARSE
        };

        try (final SeekableByteChannel channel = Files.newByteChannel(hugeFile.toPath(), options)) {
            channel.position(HUGE_FILE_SIZE);
            channel.write(buf);
        }
        LOGGER.info("Test file created");
    }
}