import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.List;
import java.util.TreeMap;
import java.util.stream.Collectors;
import java.util.stream.IntStream;


class WebserverThread extends Thread {
    // Синхронизация не нужна. У TemplateProcessor нет изменяемого состояния.
    private final TemplateProcessor templateProcessor;

    private final LinkedDocumentCollection ldc;

    private final Socket client;

    public WebserverThread(TemplateProcessor templateProcessor, LinkedDocumentCollection ldc, Socket socket) {
        this.templateProcessor = templateProcessor;
        this.ldc = ldc;
        this.client = socket;
    }

    public void communicate() throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(client.getInputStream()));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(client.getOutputStream()));

        try {
            String requestLine = in.readLine();
            if (requestLine == null)
                return;
            in.lines().takeWhile(l -> !l.equals("")).count();

            System.out.println("=> Request header received");

            HttpRequest request;
            try {
                request = new HttpRequest(requestLine);
            } catch (InvalidRequestException ex) {
                System.out.println("=> Bad request!");
                out.print(new HttpResponse(HttpStatus.BadRequest));
                return;
            }

            if (request.getMethod() != HttpMethod.GET) {
                System.out.println("=> Invalid method!");
                out.print(new HttpResponse(HttpStatus.MethodNotAllowed));
                return;
            }

            HttpResponse response;
            if (request.getPath().equals("/")) {
                System.out.println("=> Query for main page");
                response = handleMainPage();
            } else if (request.getPath().equals("/search")) {
                System.out.println("=> Search query");
                String query = request.getParameters().get("query");
                response = handleSearchRequest(query);
            } else {
                System.out.println("=> File query");
                String fileName = request.getPath().substring(1);
                response = handleFileRequest(fileName);
            }
            out.print(response);
        }
        finally {
            out.close();
        }
    }

    private  HttpResponse handleMainPage() {
        TreeMap<String, String> varass = new TreeMap<>();
        varass.put("%value", "");
        varass.put("%results", "");
        String body = templateProcessor.replace(varass);
        return new HttpResponse(HttpStatus.Ok, body);
    }

    private  HttpResponse handleSearchRequest(String query) {
        double pageRankDampingFactor = 0.85;
        double weightingFactor = 0.6;

        TreeMap<String, String> varass = new TreeMap<>();
        varass.put("%value", query);
        varass.put("%results", "");

        double[] relevance = null;

        StringBuilder msgBuilder = new StringBuilder();

        // DocumentCollection.match изменяет состояние ldc в процессе исполнения, поэтому ставим блокировку перед входом в метод
        // Нам также нужен неизмененный список названий страниц, чтобы заполнить html-код, поэтому оставляем блокировку до завершения генерации таблицы
        synchronized (ldc) {
            relevance = ldc.match(query, pageRankDampingFactor, weightingFactor);
            // Или же копируем названия страниц в отдельный список и снимаем блокировку здесь
//            List<String> pageNames = IntStream.range(0, ldc.numDocuments()).boxed().map(i -> ldc.get(i).getTitle()).collect(Collectors.toList());
            if (ldc.numDocuments() > 0)
                msgBuilder.append("<tr><td><b>ID</b></td><td><b>Page</b></td><td><b>Relevance</b></td></tr>");

            for(int i = 0; i < ldc.numDocuments(); ++i) {
                msgBuilder.append("<tr>");
                msgBuilder.append("<td>").append(i + 1).append("</td>");
                msgBuilder.append("<td><a href=\"").append(ldc.get(i).getTitle()).append("\">").append(ldc.get(i).getTitle()).append("</a></td>");
                msgBuilder.append("<td>").append(relevance[i]).append("</td>");
                msgBuilder.append("</tr>");
            }
        }

        varass.put("%results", msgBuilder.toString());
        String body = templateProcessor.replace(varass);
        return new HttpResponse(HttpStatus.Ok, body);
    }


    private HttpResponse handleFileRequest(String fileName) {
        if (fileName.contains("/"))
            return new HttpResponse(HttpStatus.Forbidden);
        String[] fileContents = Terminal.readFile(fileName);
        if (fileContents == null) {
            return new HttpResponse(HttpStatus.NotFound);
        }
        String body = fileContents[1];
        return new HttpResponse(HttpStatus.Ok, body);
    }


    @Override
    public void run() {
        try {
            communicate();
        }
        catch (IOException ex) {
            ex.printStackTrace();
        }
        finally {
            try {
                client.close();
            }
            catch (IOException ex) {
                ex.printStackTrace();
            }
        }

    }
}


public class WebServerThreads {

    public static void main(String[] args) throws IOException {
        // Создаем один обработчик шаблонов
        TemplateProcessor tp = new TemplateProcessor("html/search.html");

        // Создаем разделяемую коллекцию документов
        LinkedDocumentCollection prelim = new LinkedDocumentCollection();
        prelim.appendDocument(new LinkedDocument("B.txt", "", "", null, null, "link:A.txt link:E.txt", "B.txt"));
        LinkedDocumentCollection sharedLDC = prelim.crawl();

        ServerSocket serverSocket = new ServerSocket(8000);

        // Ожидаем новые соединения
        while(true) {
            try {
                Socket client = serverSocket.accept();
                // При новом входящем соединении создаём новый поток, передаём ему ссылки на разделяемые данные
                WebserverThread thread = new WebserverThread(tp, sharedLDC, client);
                // Запускаем поток
                thread.start();
            }
            catch (IOException ex) {
                ex.printStackTrace();
                System.exit(-1);
            }
        }
    }

}