import java.io.IOException;

public class Main {
    public static void main(String[] args) throws InterruptedException, IOException {
        // Khởi động máy chủ trên cổng 9090
        Server.run(9090);
    }
}

import org.live_server.util.FileUtil;
import org.live_server.util.RequestUtil;
import org.live_server.util.ResponseUtil;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.URL;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.concurrent.ConcurrentHashMap;
import java.util.logging.Level;
import java.util.logging.Logger;

public class Server {
    private static final Logger LOGGER = Logger.getLogger(Server.class.getName());
    private static final String rootFolderText = "static";

    public Server() {
    }

    public static void run(int port) {
        try (ServerSocket server = new ServerSocket(port)) {
            System.out.println("Chạy trên cổng : " + port);

            // Lấy URL của thư mục 'static' từ tài nguyên
            URL resource = Server.class.getResource("/" + rootFolderText);
            assert resource != null;

            // Chuyển đổi URL thành đối tượng Path
            Path rootPath = Path.of(resource.toURI());
            if (!Files.exists(rootPath)) {
                throw new RuntimeException("Không tìm thấy đường dẫn gốc (/static)!");
            }

            // Tạo bản đồ tất cả các đường dẫn tệp có sẵn để tìm kiếm nhanh
            ConcurrentHashMap<String, Path> pathConcurrentHashMap = FileUtil.generatePath(rootPath, rootFolderText);

            // Vòng lặp máy chủ để chấp nhận kết nối đến
            while (true) {
                try (Socket connection = server.accept()) {
                    // Xử lý yêu cầu cho mỗi kết nối mới
                    server(connection, pathConcurrentHashMap);
                } catch (Exception ex) {
                    LOGGER.log(Level.INFO, ex.getMessage());
                    break;
                }
            }
        } catch (Exception ex) {
            LOGGER.log(Level.INFO, ex.getMessage());
        }
    }

    private static void server(Socket connection, ConcurrentHashMap<String, Path> pathConcurrentHashMap) throws IOException {

        // Lấy URL yêu cầu từ yêu cầu của khách hàng
        String requestUrl = RequestUtil.requestedUrl(connection);
        // Tìm kiếm đường dẫn tệp trong bản đồ
        Path resultPath = pathConcurrentHashMap.get(requestUrl);

        // Kiểm tra xem đường dẫn có tồn tại và là tệp không
        if (resultPath != null && requestUrl.contains(".")) {
            // Nếu tìm thấy, gửi tệp như một phản hồi
            ResponseUtil.sendResponse(connection.getOutputStream(), pathConcurrentHashMap.get(requestUrl));
        } else {
            // Nếu không tìm thấy, gửi phản hồi 404 Not Found
            ResponseUtil.sendResponse(connection.getOutputStream(), "404 Not Found".getBytes());
        }
    }
}

import java.nio.file.Files;
import java.nio.file.Path;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Stream;

public class FileUtil {

    private FileUtil() {
    }

    // Phương thức này trả về bản đồ tất cả các đường dẫn tệp trong thư mục gốc
    public static ConcurrentHashMap<String, Path> generatePath(Path rootPath, String rootFolderText) {
        ConcurrentHashMap<String, Path> pathConcurrentHashMap = new ConcurrentHashMap<>();

        // Đi qua rootPath để tìm tất cả các tệp và thư mục
        try (Stream<Path> pathStream = Files.walk(rootPath)) {
            pathStream.toList().forEach(path -> {
                // Không bao gồm thư mục gốc
                if (path.toString().endsWith(rootFolderText)) {
                    return;
                }

                String actualPath = getActualPath(path, rootFolderText);
                if (!pathConcurrentHashMap.containsKey(actualPath)) {
                    // Chỉ bao gồm các tệp trong bản đồ (đường dẫn có ".")
                    if (actualPath.contains(".")) {
                        pathConcurrentHashMap.put(actualPath, path);
                    }
                }
            });
            return pathConcurrentHashMap;
        } catch (Exception ex) {
            return new ConcurrentHashMap<>();
        }
    }

    // Phương thức này chuyển đổi một đường dẫn tuyệt đối thành đường dẫn tương đối thân thiện với URL
    public static String getActualPath(Path path, String rootFolderText) {
        // Tìm chỉ số của thư mục gốc trong đường dẫn đầy đủ
        int rootFolderIndex = path.toString().indexOf(rootFolderText);

        // Lấy phần đường dẫn sau thư mục gốc
        String nextToRootFolder = path.toString()
                .substring(rootFolderIndex + (rootFolderText.length()) + 1);
        String[] actualFolderPath;

        // Tách đường dẫn dựa trên dấu phân cách tệp của hệ điều hành
        if (SystemUtil.OS.toLowerCase().contains("windows")) {
            actualFolderPath = nextToRootFolder.split("\\\\");
        } else {
            actualFolderPath = nextToRootFolder.split("/");
        }

        // Xây dựng lại đường dẫn với dấu gạch chéo phía trước để đảm bảo tính nhất quán URL
        StringBuilder pathBuilder = new StringBuilder();
        for (String s : actualFolderPath) {
            pathBuilder.append("/")
                    .append(s);
        }

        // Xóa dấu gạch chéo đầu tiên và trả về đường dẫn
        return pathBuilder.toString().replaceFirst("/", "");
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;

public class RequestUtil {
    private RequestUtil() {
    }

    // Phương thức này trích xuất URL được yêu cầu từ yêu cầu của khách hàng
    public static String requestedUrl(Socket socket) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));

        // Đọc dòng đầu tiên của yêu cầu HTTP (ví dụ: "GET /index.html HTTP/1.1")
        String line = bufferedReader.readLine();
        if (line == null)
            return "";

        // Tách dòng theo khoảng trắng
        String[] requestLineParts = line.split("\\s+");
        if (requestLineParts.length >= 2) {
            // URL được yêu cầu là phần thứ hai
            return requestLineParts[1].replaceFirst("/", "")
                    .replaceFirst("\\\\", "");
        }

        return "";
    }
}

import java.io.IOException;
import java.io.OutputStream;
import java.nio.file.Files;
import java.nio.file.Path;

public class ResponseUtil {

    private ResponseUtil(){}

    // Gửi một mảng byte như một phản hồi HTTP
    public static void sendResponse(OutputStream outputStream, byte[] bytes) throws IOException {
        // Gửi dòng trạng thái HTTP và tiêu đề
        outputStream.write("HTTP/1.1 200 OK\r\n".getBytes());
        outputStream.write("Cache-Control: no-cache, no-store, must-revalidate\r\n".getBytes());
        outputStream.write("Pragma: no-cache\r\n".getBytes());
        outputStream.write("Expires: 0\r\n".getBytes());
        outputStream.write("\r\n".getBytes());

        // Gửi nội dung tệp thực tế (mảng byte)
        outputStream.write(bytes);
        outputStream.flush();
    }

    // Phương thức quá tải để gửi tệp từ một Path cho trước
    public static void sendResponse(OutputStream outputStream, Path path) throws IOException {
        if (Files.exists(path)) {
            // Đọc tất cả byte từ tệp và gửi chúng
            byte[] bytes = Files.readAllBytes(path);
            sendResponse(outputStream, bytes);
        } else {
            // Nếu tệp không tồn tại, gửi phản hồi 404
            sendResponse(outputStream, "404 Not Found!".getBytes());
        }
    }
}

public class SystemUtil {
    private SystemUtil(){}

    // Một hằng số để lưu trữ tên của hệ điều hành
    public static final String OS = System.getProperty("os.name");
}