package zw.qantra.tm.domain.controllers;

import lombok.RequiredArgsConstructor;
import net.kaczmarzyk.spring.data.jpa.domain.Equal;
import net.kaczmarzyk.spring.data.jpa.domain.EqualIgnoreCase;
import net.kaczmarzyk.spring.data.jpa.web.annotation.And;
import net.kaczmarzyk.spring.data.jpa.web.annotation.Spec;
import org.hibernate.query.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import zw.qantra.tm.domain.dtos.GroupCreateFromFileRequest;
import zw.qantra.tm.domain.dtos.GroupCreateFromFileResult;
import zw.qantra.tm.domain.dtos.GroupMemberRequest;
import zw.qantra.tm.domain.dtos.RecipientGroupCreateRequest;
import zw.qantra.tm.domain.dtos.RecipientGroupUpdateRequest;
import zw.qantra.tm.domain.models.RecipientGroup;
import zw.qantra.tm.domain.models.RecipientGroupMember;
import zw.qantra.tm.domain.services.RecipientGroupService;

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

@RestController
@RequestMapping("/recipient-groups")
@RequiredArgsConstructor
public class RecipientGroupController {
    private final RecipientGroupService recipientGroupService;

    @GetMapping
    public ResponseEntity findAll(
            @And({
                    @Spec(path = "name", spec = EqualIgnoreCase.class),
                    @Spec(path = "workspaceId", defaultVal = "null", spec = Equal.class)
            })Specification<RecipientGroup> spec, Pageable pageable) {
        return ResponseEntity.ok(recipientGroupService.findAll(spec, pageable));
    }

    @PostMapping
    public ResponseEntity<RecipientGroup> create(@RequestBody RecipientGroupCreateRequest request) {
        RecipientGroup group = RecipientGroup.builder()
                .name(request.getName())
                .description(request.getDescription())
                .workspaceId(request.getWorkspaceId())
                .userId(request.getUserId())
                .build();
        return ResponseEntity.ok(recipientGroupService.create(group, request.getRecipients()));
    }

    @PostMapping(value = "/create-from-file", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
    public ResponseEntity<GroupCreateFromFileResult> createFromFile(
            @RequestParam("file") MultipartFile file,
            @RequestParam("groupName") String groupName,
            @RequestParam(value = "description", required = false) String description,
            @RequestParam(value = "requestedBy", required = false) String requestedBy,
            @RequestParam(value = "currency", required = false) String currency,
            @RequestParam("userId") UUID userId,
            @RequestParam("workspaceId") UUID workspaceId
    ) {

        GroupCreateFromFileRequest request = new GroupCreateFromFileRequest();
        request.setGroupName(groupName.trim());
        request.setDescription(description.trim());
        request.setRequestedBy(requestedBy);
        request.setCurrency(currency);
        request.setWorkspaceId(workspaceId);
        request.setUserId(userId);

        return ResponseEntity.ok(recipientGroupService.createFromFile(file, request));
    }

    @PutMapping("/update/{groupId}")
    public ResponseEntity<RecipientGroup> update(@PathVariable UUID groupId,
                                                 @RequestBody RecipientGroupUpdateRequest request) {
        return ResponseEntity.ok(recipientGroupService.update(
                groupId,
                request.getWorkspaceId(),
                request.getName(),
                request.getDescription()));
    }

    @DeleteMapping("/delete/{groupId}")
    public ResponseEntity<Void> delete(@PathVariable UUID groupId,
                                       @RequestParam UUID workspaceId) {
        recipientGroupService.delete(groupId, workspaceId);
        return ResponseEntity.noContent().build();
    }

    @PostMapping("/{groupId}/members")
    public ResponseEntity<List<RecipientGroupMember>> addMembersByIds(@PathVariable UUID groupId,
                                                                       @RequestBody GroupMemberRequest request) {
        return ResponseEntity.ok(recipientGroupService.addMembersByIds(
                groupId,
                request.getWorkspaceId(),
                request.getRecipientIds()));
    }

    @DeleteMapping("/{groupId}/members/{recipientId}")
    public ResponseEntity<Void> removeMember(@PathVariable UUID groupId,
                                             @PathVariable UUID recipientId,
                                              @RequestParam UUID workspaceId) {
        recipientGroupService.removeMember(groupId, recipientId, workspaceId);
        return ResponseEntity.noContent().build();
    }

    @GetMapping("/members")
    public ResponseEntity members(
            @And({
                    @Spec(path = "recipientGroupId", spec = Equal.class),
            }) Specification<RecipientGroupMember> spec, Pageable pageable) {
        return ResponseEntity.ok(recipientGroupService.findAllMembers(spec, pageable));
    }
}