lr-openvpn-backend/src/main/java/com/litoralregas/openvpn/router/RouterController.java

package com.litoralregas.openvpn.router;

import com.litoralregas.openvpn.deployment.DeploymentAction;
import com.litoralregas.openvpn.deployment.DeploymentResponse;
import com.litoralregas.openvpn.deployment.DeploymentService;
import jakarta.validation.Valid;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.UUID;

@RestController
@RequestMapping("/api/routers")
public class RouterController {

    private final RouterService service;
    private final DeploymentService deploymentService;

    public RouterController(RouterService service, DeploymentService deploymentService) {
        this.service = service;
        this.deploymentService = deploymentService;
    }

    @GetMapping
    public List<Router> getAll() {
        return service.findAll();
    }

    @PostMapping
    public Router create(@Valid @RequestBody CreateRouterRequest request) {
        return service.create(request);
    }

    @GetMapping("/{id}")
    public Router getById(@PathVariable UUID id) {
        return service.findById(id);
    }

    @PatchMapping("/{id}/status")
    public Router updateStatus(
            @PathVariable UUID id,
            @Valid @RequestBody UpdateRouterStatusRequest request
    ) {
        return service.updateStatus(id, request);
    }

    @DeleteMapping("/{id}")
    public void delete(@PathVariable UUID id) {
        service.delete(id);
    }

    @PostMapping("/{id}/provision")
    public DeploymentResponse provision(@PathVariable UUID id) {
        Router router = service.findById(id);

        var deployment = deploymentService.startDeployment(router, DeploymentAction.PROVISION);

        try {
            service.forceStatus(id, RouterStatus.PROVISIONING);

            // Simulated provisioning for now.
            var finishedDeployment = deploymentService.finishSuccess(
                    deployment,
                    "Provision completed successfully"
            );

            service.forceStatus(id, RouterStatus.PROVISIONED);

            return DeploymentResponse.from(finishedDeployment);
        } catch (Exception exception) {
            var failedDeployment = deploymentService.finishFailure(
                    deployment,
                    exception.getMessage()
            );

            service.forceStatus(id, RouterStatus.FAILED);

            return DeploymentResponse.from(failedDeployment);
        }
    }

    @PostMapping("/{id}/remove")
    public DeploymentResponse remove(@PathVariable UUID id) {
        Router router = service.findById(id);

        var deployment = deploymentService.startDeployment(router, DeploymentAction.REMOVE);

        try {
            service.forceStatus(id, RouterStatus.PROVISIONING); // or REMOVING if you want later

            // simulate removal
            var finished = deploymentService.finishSuccess(
                    deployment,
                    "Removal completed successfully"
            );

            service.forceStatus(id, RouterStatus.REMOVED);

            return DeploymentResponse.from(finished);
        } catch (Exception e) {
            var failed = deploymentService.finishFailure(
                    deployment,
                    e.getMessage()
            );

            service.forceStatus(id, RouterStatus.FAILED);

            return DeploymentResponse.from(failed);
        }
    }
}