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.ResponseEntity;
import org.springframework.web.bind.annotation.*;
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("/public/recipient-groups")
@RequiredArgsConstructor
public class RecipientGroupController {
    private final RecipientGroupService recipientGroupService;

    @GetMapping
    public ResponseEntity findAll(
            @And({
                    @Spec(path = "name", spec = EqualIgnoreCase.class),
                    @Spec(path = "userId", 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())
                .userId(request.getUserId())
                .build();
        return ResponseEntity.ok(recipientGroupService.create(group, request.getRecipients()));
    }

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

    @DeleteMapping("/delete/{groupId}")
    public ResponseEntity<Void> delete(@PathVariable UUID groupId,
                                       @RequestParam String userId) {
        recipientGroupService.delete(groupId, userId);
        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.getUserId(),
                request.getRecipientIds()));
    }

    @DeleteMapping("/{groupId}/members/{recipientId}")
    public ResponseEntity<Void> removeMember(@PathVariable UUID groupId,
                                             @PathVariable UUID recipientId,
                                             @RequestParam String userId) {
        recipientGroupService.removeMember(groupId, recipientId, userId);
        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));
    }
}