package com.plannaplan.controllers;

import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;

import com.plannaplan.App;
import com.plannaplan.entities.Assignment;
import com.plannaplan.entities.Exchange;
import com.plannaplan.entities.Groups;
import com.plannaplan.entities.User;
import com.plannaplan.exceptions.UserNotFoundException;
import com.plannaplan.responses.mappers.ExchangeResponseMappers;
import com.plannaplan.responses.models.ExchangeResponse;
import com.plannaplan.services.AssignmentService;
import com.plannaplan.services.ExchangeService;
import com.plannaplan.services.GroupService;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;

/**
 * Rest controller to Exchange related endpoints. More detailed api docs is
 * available via swagger
 */
@RestController
@CrossOrigin
@RequestMapping("/api/" + App.API_VERSION + "/exchanges")
@Api(tags = { "Exchange" }, value = "Exchange", description = "Endpoint to exchange with accepted assignments.")
public class ExchangeController extends TokenBasedController {

    @Autowired
    private GroupService groupService;

    @Autowired
    private AssignmentService assignmentService;

    @Autowired
    private ExchangeService exchangeService;

    /**
     * @param exchangeRequest mapped json body with requierd paramas (groupid and
     *                        assignment)
     * @return was job successfull
     * @throws UserNotFoundException if user was not found
     */
    @PostMapping("/exchange")
    @ApiOperation(value = "Creates exchange offer.")
    public ResponseEntity<String> createExchange(
            @ApiParam(value = "Json object that contains assignment to trade and desired group. For example: { \"assignment\": 3, \"group\":32 }") @RequestBody Map<String, Long> exchangeRequest)
            throws UserNotFoundException {

        final User asker = this.getCurrentUser().orElseThrow(() -> new UserNotFoundException("Invalid token"));
        final Long assignmentId = exchangeRequest.get("assignment");
        final Long groupId = exchangeRequest.get("group");
        final List<Long> ownedGroups = asker.getStudentRegisteredGrups().stream().map(Groups::getId)
                .collect(Collectors.toList());

        if (ownedGroups.contains(groupId)) {
            return new ResponseEntity<>("User has already got this group.", HttpStatus.BAD_REQUEST);
        }

        if (assignmentId == null || groupId == null) {
            return new ResponseEntity<>("Some of values are missing", HttpStatus.BAD_REQUEST);
        }

        final Optional<Assignment> assignment = this.assignmentService.getById(assignmentId);
        final Optional<Groups> group = this.groupService.getGroupById(groupId);

        if (assignment.isEmpty() || group.isEmpty()) {
            return new ResponseEntity<>("Some of provided value does not exist.", HttpStatus.BAD_REQUEST);
        }

        final Assignment assignmentInstance = assignment.get();
        final Groups groupInstance = group.get();

        if (assignmentInstance.getGroup().getCourseId() != null
                && ! assignmentInstance.getGroup().getCourseId().getId().equals(groupInstance.getCourseId().getId())) {
            return new ResponseEntity<>("You can performe exchange only within one course.", HttpStatus.BAD_REQUEST);
        }

        if (assignmentInstance.getGroup().getType() != groupInstance.getType()) {
            return new ResponseEntity<>("You can't exchange lecture to class and otherwise.", HttpStatus.BAD_REQUEST);
        }

        if (!(assignmentInstance.getCommision().getCommisionOwner().getId().equals(asker.getId())
                && assignmentInstance.isAccepted())) {
            return new ResponseEntity<>(
                    "Some of problems appeared. Check if you have access to given assignment and if it is accepted or the exchange has not been already added.",
                    HttpStatus.BAD_REQUEST);
        }

        this.exchangeService.save(new Exchange(assignmentInstance, groupInstance));

        return new ResponseEntity<>("Success", HttpStatus.OK);
    }

    /**
     * @param offerId id to delwete from db
     * @return was jub successful
     * @throws UserNotFoundException if user was not found
     */
    @DeleteMapping("/exchange/{id}")
    @ApiOperation(value = "Delete exchange offer")
    public ResponseEntity<String> deleteExchange(@PathVariable(name = "id", required = false) Long offerId)
            throws UserNotFoundException {

        final User asker = this.getCurrentUser().orElseThrow(() -> new UserNotFoundException("Invalid token"));

        final Optional<Exchange> exchange = this.exchangeService.getById(offerId);

        if (exchange.isEmpty()) {
            return new ResponseEntity<>("Given offer does not exist.", HttpStatus.BAD_REQUEST);
        }

        final Exchange exchangeToDelete = exchange.get();

        if (!(exchangeToDelete.getOwnedAssignment().getCommision().getCommisionOwner().getId().equals(asker.getId()))) {
            return new ResponseEntity<>("You have not permission for that action.", HttpStatus.BAD_REQUEST);
        }

        this.exchangeService.deleteExchange(exchangeToDelete);
        return new ResponseEntity<>("Success", HttpStatus.OK);
    }

    /**
     * @return return all user's exchange offers
     * @throws UserNotFoundException iF user was not found
     */
    @GetMapping("/exchange/all")
    @ApiOperation(value = "Get exchange offers")
    public ResponseEntity<List<ExchangeResponse>> getExchange() throws UserNotFoundException {

        final User asker = this.getCurrentUser().orElseThrow(() -> new UserNotFoundException("Invalid token"));

        final List<Exchange> response = exchangeService.getByUserId(asker.getId());
        final List<ExchangeResponse> listOfResponses = ExchangeResponseMappers.mapToDefaultResponse(response);

        return new ResponseEntity<>(listOfResponses, HttpStatus.OK);
    }

    /**
     * @param offerId id of exchange in db
     * @return Exchage response
     * @throws UserNotFoundException if user was not found
     */
    @GetMapping("/exchange/{id}")
    @ApiOperation(value = "Get exchange offer")
    public ResponseEntity<ExchangeResponse> getExchangeById(@PathVariable(name = "id", required = false) Long offerId)
            throws UserNotFoundException {

        final User asker = this.getCurrentUser().orElseThrow(() -> new UserNotFoundException("Invalid token"));

        final Optional<Exchange> exchange = this.exchangeService.getById(offerId);

        if (exchange.isEmpty()) {
            return new ResponseEntity<>(null, HttpStatus.BAD_REQUEST);
        }

        final Exchange exchangeInstance = exchange.get();
        if (!exchangeInstance.getOwnerId().equals(asker.getId())) {
            return new ResponseEntity<>(null, HttpStatus.BAD_REQUEST);
        }

        return new ResponseEntity<>(new ExchangeResponse(exchangeInstance), HttpStatus.OK);
    }
}