package fr.la_banquise.backend.services;

import com.github.dockerjava.api.DockerClient;
import com.github.dockerjava.api.command.BuildImageResultCallback;
import com.github.dockerjava.api.command.CreateContainerResponse;
import com.github.dockerjava.api.command.InspectContainerResponse;
import com.github.dockerjava.api.model.Container;
import com.github.dockerjava.api.model.ContainerPort;
import com.github.dockerjava.api.model.ExposedPort;
import com.github.dockerjava.api.model.HostConfig;
import com.github.dockerjava.api.model.PortBinding;
import com.github.dockerjava.api.model.Ports;

import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;

import java.io.File;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.ArrayList;
import fr.la_banquise.backend.rest.response.DockerResponse;

@ApplicationScoped
public class DockerService {

    @Inject
    DockerClient dockerClient;

    public String createAndStartNginx() {
        ExposedPort tcp80 = ExposedPort.tcp(80);

        Ports portBindings = new Ports();
        portBindings.bind(tcp80, Ports.Binding.bindPort(8081));

        HostConfig hostConfig = HostConfig.newHostConfig().withPortBindings(portBindings);
        Map<String, String> labels = new HashMap<>();
        labels.put("test", "banquise");
        labels.put("environment", "development");
        labels.put("version", "1.0");
        labels.put("created-by", "java-docker-api");

        CreateContainerResponse container = dockerClient.createContainerCmd("nginx:latest")
                .withName("my-nginx")
                .withLabels(labels)
                .withExposedPorts(tcp80)
                .withHostConfig(hostConfig)
                .exec();

        dockerClient.startContainerCmd(container.getId()).exec();
        return container.getId();
    }

    /*
     * public String listAllContainers() {
     * StringBuilder json = new StringBuilder();
     * List<Container> containers = dockerClient.listContainersCmd()
     * .withShowAll(true)
     * .exec();
     * 
     * json.append("[");
     * 
     * for (int i = 0; i < containers.size(); i++) {
     * Container container = containers.get(i);
     * 
     * json.append("{");
     * json.append("\"name\":\"").append(container.getNames()[0].substring(1)).
     * append("\",");
     * json.append("\"id\":\"").append(container.getId()).append("\",");
     * json.append("\"image\":\"").append(container.getImage()).append("\",");
     * json.append("\"status\":\"").append(container.getStatus()).append("\",");
     * 
     * // Ports
     * InspectContainerResponse inspectResponse =
     * dockerClient.inspectContainerCmd(container.getId()).exec();
     * json.append("\"ports\":[");
     * if (container.getPorts() != null && container.getPorts().length > 0) {
     * for (int j = 0; j < .length; j+=2) {
     * ContainerPort port = container.getPorts()[j];
     * json.append("[\"");
     * json.append(port.getPrivatePort()).append("->").append(port.getPublicPort()).
     * append("/"+port.getType()+"\",\"");
     * json.append(port.getIp()).append(",").append((container.getPorts()[j+1]).
     * getIp());
     * if (port.getType() != null) {
     * json.append("/").append(port.getType());
     * }
     * if (port.getPublicPort() != null) {
     * json.append("->").append(port.getPublicPort());
     * }*
     * json.append("\"]");
     * if (j < container.getPorts().length - 2) {
     * json.append(",");
     * }
     * }
     * }
     * json.append("]");
     * 
     * // Ports
     * String ports = "[]";
     * try {
     * InspectContainerResponse inspectResponse =
     * dockerClient.inspectContainerCmd(container.getId()).exec(); if
     * (inspectResponse.getConfig().getExposedPorts() != null) { ports =
     * inspectResponse.getConfig().getExposedPorts().toString();
     * }
     * } catch (Exception e) {
     * // Fallback vers les ports runtime si inspect échoue
     * if (container.getPorts() != null && container.getPorts().length
     * > 0) { ports = java.util.Arrays.toString(container.getPorts());
     * }
     * }
     * json.append("\"ports\":\"").append(ports).append("\"");
     * json.append("}");
     * if (i < containers.size() - 1) {
     * json.append(",");
     * }
     * 
     * json.append("}");
     * 
     * if (i < containers.size() - 1) {
     * json.append(",");
     * }
     * }
     * 
     * json.append("]");
     * return json.toString();
     * }
     * public String listAllContainers() {
     * StringBuilder json = new StringBuilder();
     * List<Container> containers = dockerClient.listContainersCmd()
     * .withShowAll(true)
     * .exec();
     * json.append("[");
     * for (int i = 0; i < containers.size(); i++) {
     * Container container = containers.get(i);
     * // Ports
     * List<String> portsList = new ArrayList<>();
     * try {
     * var inspectResponse =
     * dockerClient.inspectContainerCmd(container.getId()).exec(); if
     * (inspectResponse.getConfig().getExposedPorts() != null) { var exposedPorts =
     * inspectResponse.getConfig().getExposedPorts(); int count = 0; for (var port
     * : exposedPorts) { if (count > 0) portsList.append(",");
     * portsList.append(String.format("\"%s\"",
     * port.toString())); count = 1;
     * }
     * portsList.append("]");
     * ports = portsList.toString();
     * }
     * } catch (Exception e) {
     * // Fallback vers les ports runtime si inspect échoue
     * if (container.getPorts() != null && container.getPorts().length
     * > 0) { ports = java.util.Arrays.toString(container.getPorts());
     * }
     * }
     * 
     * //json.append(containerJson);
     * 
     * if (i < containers.size() - 1) {
     * json.append(",");
     * }
     * }
     * json.append("]");
     * return json.toString();
     * }
     */

    ////////////////////
    public String createContainer(String name, int port) {
        ExposedPort tcpSsh = ExposedPort.tcp(2222);

        Ports portBindings = new Ports();
        portBindings.bind(tcpSsh, Ports.Binding.bindPort(port));

        HostConfig hostConfig = HostConfig.newHostConfig().withPortBindings(portBindings);
        Map<String, String> labels = new HashMap<>();
        labels.put("test", "banquise");
        labels.put("environment", "development");
        labels.put("version", "1.0");
        labels.put("created-by", "java-docker-api");

        dockerClient.buildImageCmd()
                .withDockerfile(new File("./dockerfile/Dockerfile"))
                .withBaseDirectory(new File("./dockerfile"))
                .withTags(Set.of("ji-python:latest"))
                .exec(new BuildImageResultCallback())
                .awaitImageId();

        CreateContainerResponse container = dockerClient.createContainerCmd("ji-python:latest")
                .withName(name)
                .withLabels(labels)
                .withExposedPorts(tcpSsh)
                .withHostConfig(hostConfig)
                .withEnv(
                        "SUDO_ACCESS=false",
                        "PASSWORD_ACCESS=true",
                        "USER_NAME=test", // TODO: CHANGE THIS
                        "USER_PASSWORD=test" // AND this also oc
                )
                .exec();

        return container.getId();
    }

    public InspectContainerResponse.ContainerState getStatusContainer(String name) {
        InspectContainerResponse container = dockerClient.inspectContainerCmd(name).exec();
        return container.getState();
    }

    public boolean remove(String name) {
        try {
            dockerClient.removeContainerCmd(name).exec();
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    public boolean containerExists(String name) {
        try {
            dockerClient.inspectContainerCmd(name).exec();
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    public void start(String containerId) {
        dockerClient.startContainerCmd(containerId).exec();
    }

    public void stop(String containerId) {
        dockerClient.stopContainerCmd(containerId).exec();
    }

    public List<DockerResponse> listAllContainers() {
        List<Container> containers = dockerClient.listContainersCmd()
                .withShowAll(true)
                .exec();
        return containers.stream().map(this::toDockerResponse).toList();
    }

    private DockerResponse toDockerResponse(Container container) {
        List<String> portsList = new ArrayList<>();
        for (var port : container.getPorts()) {
            portsList.add(String.format("%s:%s", port.getPrivatePort(), port.getPublicPort()));
        }

        return new DockerResponse(container.getNames()[0].substring(1), container.getStatus(), container.getImage(),
                portsList);
    }

}