package org.apache.maven.it;

import com.google.common.io.ByteStreams;
import org.eclipse.jetty.security.ConstraintMapping;
import org.eclipse.jetty.security.ConstraintSecurityHandler;
import org.eclipse.jetty.security.HashLoginService;
import org.eclipse.jetty.security.authentication.BasicAuthenticator;
import org.eclipse.jetty.server.Connector;
import org.eclipse.jetty.server.NetworkConnector;
import org.eclipse.jetty.server.Request;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.ServerConnector;
import org.eclipse.jetty.server.handler.AbstractHandler;
import org.eclipse.jetty.util.security.Constraint;
import org.eclipse.jetty.util.security.Password;
import org.eclipse.jetty.util.thread.QueuedThreadPool;
import org.eclipse.jetty.util.thread.ScheduledExecutorScheduler;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URL;
import java.util.Collections;

/**
 * An HTTP server that handles all requests on a given port from a specified source, optionally secured using BASIC auth
 * by providing a username and password. The source can either be a URL or a directory. When a request is made the
 * request is satisfied from the provided source.
 *
 * @author Jason van Zyl
 */
public class HttpServer
{

    private final Server server;

    private final StreamSource source;

    private final String username;

    private final String password;

    public HttpServer( int port, String username, String password, StreamSource source )
    {
        this.username = username;
        this.password = password;
        this.source = source;
        this.server = server( port );
    }

    public void start()
        throws Exception
    {
        server.start();
        // server.join();
    }

    public void stop()
        throws Exception
    {
        server.stop();
    }

    public int port()
    {
        return ( (NetworkConnector) server.getConnectors()[0] ).getLocalPort();
    }

    private Server server( int port )
    {
        QueuedThreadPool threadPool = new QueuedThreadPool();
        threadPool.setMaxThreads( 500 );
        Server server = new Server( threadPool );
        server.setConnectors( new Connector[]{ new ServerConnector( server ) } );
        server.addBean( new ScheduledExecutorScheduler() );

        ServerConnector connector = (ServerConnector) server.getConnectors()[0];
        connector.setIdleTimeout( 30_000L );
        connector.setPort( port );

        StreamSourceHandler handler = new StreamSourceHandler( source );

        if ( username != null && password != null )
        {
            HashLoginService loginService = new HashLoginService( "Test Server" );
            loginService.putUser( username, new Password( password ), new String[]{ "user" } );
            server.addBean( loginService );

            ConstraintSecurityHandler security = new ConstraintSecurityHandler();
            server.setHandler( security );

            Constraint constraint = new Constraint();
            constraint.setName( "auth" );
            constraint.setAuthenticate( true );
            constraint.setRoles( new String[]{ "user", "admin" } );

            ConstraintMapping mapping = new ConstraintMapping();
            mapping.setPathSpec( "/*" );
            mapping.setConstraint( constraint );

            security.setConstraintMappings( Collections.singletonList( mapping ) );
            security.setAuthenticator( new BasicAuthenticator() );
            security.setLoginService( loginService );
            security.setHandler( handler );
        }
        else
        {
            server.setHandler( handler );
        }
        return server;
    }

    public static HttpServerBuilder builder()
    {
        return new HttpServerBuilder();
    }

    public static class HttpServerBuilder
    {

        private int port;

        private String username;

        private String password;

        private StreamSource source;

        public HttpServerBuilder port( int port )
        {
            this.port = port;
            return this;
        }

        public HttpServerBuilder username( String username )
        {
            this.username = username;
            return this;
        }

        public HttpServerBuilder password( String password )
        {
            this.password = password;
            return this;
        }

        public HttpServerBuilder source( final String source )
        {
            this.source = new StreamSource()
            {
                @Override
                public InputStream stream( String path )
                    throws IOException
                {
                    return new URL( String.format( "%s/%s", source, path ) ).openStream();
                }
            };
            return this;
        }

        public HttpServerBuilder source( final File source )
        {
            this.source = new StreamSource()
            {
                @Override
                public InputStream stream( String path )
                    throws IOException
                {
                    return new FileInputStream( new File( source, path ) );
                }
            };
            return this;
        }

        public HttpServer build()
        {
            return new HttpServer( port, username, password, source );
        }
    }

    public interface StreamSource
    {
        InputStream stream( String path )
            throws IOException;
    }

    public static class StreamSourceHandler
        extends AbstractHandler
    {

        private final StreamSource source;

        public StreamSourceHandler( StreamSource source )
        {
            this.source = source;
        }

        @Override
        public void handle( String target, Request baseRequest, HttpServletRequest request,
                            HttpServletResponse response )
            throws IOException, ServletException
        {
            response.setContentType( "application/octet-stream" );
            response.setStatus( HttpServletResponse.SC_OK );
            try ( InputStream in = source.stream(
                target.substring( 1 ) ); OutputStream out = response.getOutputStream() )
            {
                ByteStreams.copy( in, out );
            }
            baseRequest.setHandled( true );
        }
    }

    public static void main( String[] args )
        throws Exception
    {
        HttpServer server = HttpServer.builder() //
            .port( 0 ) //
            .username( "maven" ) //
            .password( "secret" ) //
            .source( new File( "/tmp/repo" ) ) //
            .build();
        server.start();
    }
}