package com.plannaplan.responses.mappers;

import java.util.List;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;

import com.plannaplan.entities.Assignment;
import com.plannaplan.entities.Course;
import com.plannaplan.entities.Groups;
import com.plannaplan.responses.models.AssignmentDetailedResponse;
import com.plannaplan.responses.models.AssignmentResponse;
import com.plannaplan.types.GroupType;

/**
 * Mappers for Assingnmetns to api responses
 */
public class AssignmentResponseMappers {

    /**
     * @param assignments lsit of assignments to be maped
     * @return list of api responses
     */
    public static final List<AssignmentResponse> mapToResponse(List<Assignment> assignments) {
        return mapToResponse(assignments, null);
    }

    /**
     * 
     * @param assignments lsit of assignments to be maped
     * @param ammounts    ammounts to be take into account
     * @return list of api responses
     */
    public static final List<AssignmentResponse> mapToResponse(List<Assignment> assignments,
            HashMap<Long, Integer> ammounts) {
        List<AssignmentResponse> response = new ArrayList<>();
        HashMap<Course, List<Assignment>> courses = new HashMap<>();
        assignments.stream().forEach((Assignment assignment) -> {
            final Groups group = assignment.getGroup();
            final Course course = group.getCourseId();
            if (courses.get(course) == null) {
                courses.put(course, new ArrayList<>());
            }
            courses.get(course).add(assignment);
        });

        for (Map.Entry<Course, List<Assignment>> entry : courses.entrySet()) {
            final Course course = entry.getKey();
            final List<Assignment> courseGroups = entry.getValue();
            if (courseGroups.size() == 1) {
                if (ammounts != null) {
                    response.add(new AssignmentResponse(course, courseGroups.get(0), ammounts));
                } else {
                    response.add(new AssignmentResponse(course, courseGroups.get(0)));
                }
            }
            if (courseGroups.size() == 2) {
                final Assignment lecture = courseGroups.stream()
                        .filter(o -> GroupType.isLectureOrClass(o.getGroup().getType()) == GroupType.LECTURE)
                        .findFirst().get();
                final Assignment classes = courseGroups.stream()
                        .filter(o -> GroupType.isLectureOrClass(o.getGroup().getType()) == GroupType.CLASS).findFirst()
                        .get();

                if (ammounts != null) {
                    response.add(new AssignmentResponse(course, lecture, classes, ammounts));
                } else {
                    response.add(new AssignmentResponse(course, lecture, classes));
                }

            }
        }
        return response;
    }

    /**
     * map assignmetn to detailed response
     * 
     * @param assignments list of assignments to map
     * @return list of responses
     */
    public static final List<AssignmentDetailedResponse> mapAssignmetnToDetialedResponse(List<Assignment> assignments) {
        return assignments.stream().filter(Objects::nonNull).map(AssignmentDetailedResponse::new)
                .collect(Collectors.toList());
    }
}