package com.example.familymap;

import com.google.android.gms.maps.model.Marker;
import com.google.android.gms.maps.model.Polyline;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

import model.Event;
import model.Person;

public class DataCache
{
    /**
     * DataCache operations
     */
    private static DataCache instance = new DataCache();

    private DataCache() {}

    public void clearInstance() {
        instance = null;
    }

    public static DataCache getInstance()
    {
        if (instance == null)
        {
            instance = new DataCache();
        }

        return instance;
    }

    /**
     * Lists of persons and events
     */
    private List<Person> allPersons = new ArrayList<>();
    private List<Event> allEvents = new ArrayList<>();

    public List<Person> getAllPersons() {
        return allPersons;
    }

    public List<Event> getAllEvents() {
        return allEvents;
    }

    private List<Event> maleEvents = new ArrayList<>();
    private List<Event> femaleEvents = new ArrayList<>();

    public List<Event> getMaleEvents() {
        return maleEvents;
    }

    public List<Event> getFemaleEvents() {
        return femaleEvents;
    }

    private List<String> paternalAncestors = new ArrayList<>();
    private List<String> maternalAncestors = new ArrayList<>();

    private List<Event> malePaternalEvents = new ArrayList<>();
    private List<Event> femalePaternalEvents = new ArrayList<>();

    private List<Event> maleMaternalEvents = new ArrayList<>();
    private List<Event> femaleMaternalEvents = new ArrayList<>();

    public List<String> getPaternalAncestors() {
        return paternalAncestors;
    }

    public List<String> getMaternalAncestors() {
        return maternalAncestors;
    }

    public List<Event> getMalePaternalEvents()
    {
        return malePaternalEvents;
    }

    public List<Event> getFemalePaternalEvents()
    {
        return femalePaternalEvents;
    }

    public List<Event> getMaleMaternalEvents()
    {
        return maleMaternalEvents;
    }

    public List<Event> getFemaleMaternalEvents()
    {
        return femaleMaternalEvents;
    }

    /**
     * Maps and marker data structures
     */
    private Map<String, Person> personByIDMap = new TreeMap<>();

    public Map<String, Person> getPersonByIDMap()
    {
        return personByIDMap;
    }

    private Map<String, List<Person>> personFamilyMap = new TreeMap<>();

    public Map<String, List<Event>> personEventsMap = new TreeMap<>();

    public Map<String, List<Person>> getPersonFamilyMap()
    {
        return personFamilyMap;
    }

    public Map<String, List<Event>> getPersonEventsMap()
    {
        return personEventsMap;
    }

    private Map<String, Integer> markerColorsMap = new TreeMap<>();
    private List<Marker> markers = new ArrayList<>();

    public Map<String, Integer> getMarkerColorsMap()
    {
        return markerColorsMap;
    }

    public List<Marker> getMarkers()
    {
        return markers;
    }

    /**
     * User person and eventID
     */
    public Person userPerson;
    private String currentEventID;
    private boolean fromEventActivity = false;

    public void setUserPerson(Person userPerson)
    {
        this.userPerson = userPerson;
    }

    public Person getUserPerson()
    {
        return userPerson;
    }

    public void setCurrentEventID(String eventID)
    {
        currentEventID = eventID;
    }

    public String getCurrentEventID()
    {
        return currentEventID;
    }

    public void setFromEventActivity(boolean condition)
    {
        fromEventActivity = condition;
    }

    public boolean isFromEventActivity()
    {
        return fromEventActivity;
    }

    /**
     * Settings
     */
    private boolean showLifeStoryLines = true;
    private boolean showFamilyTreeLines = true;
    private boolean showSpouseLines = true;
    private boolean showFathersSide = true;
    private boolean showMothersSide = true;
    private boolean showMaleEvents = true;
    private boolean showFemaleEvents = true;

    public void setShowLifeStoryLines(boolean condition)
    {
        showLifeStoryLines = condition;
    }

    public boolean showLifeStoryLines()
    {
        return showLifeStoryLines;
    }

    public void setShowFamilyTreeLines(boolean condition)
    {
        showFamilyTreeLines = condition;
    }

    public boolean showFamilyTreeLines()
    {
        return showFamilyTreeLines;
    }

    public void setShowSpouseLines(boolean condition)
    {
        showSpouseLines = condition;
    }

    public boolean showSpouseLines()
    {
        return showSpouseLines;
    }

    public void setShowFathersSide(boolean condition)
    {
        showFathersSide = condition;
    }

    public boolean showFathersSide()
    {
        return showFathersSide;
    }

    public void setShowMothersSide(boolean condition)
    {
        showMothersSide = condition;
    }

    public boolean showMothersSide()
    {
        return showMothersSide;
    }

    public void setShowMaleEvents(boolean condition)
    {
        showMaleEvents = condition;
    }

    public boolean showMaleEvents()
    {
        return showMaleEvents;
    }

    public void setShowFemaleEvents(boolean condition)
    {
        showFemaleEvents = condition;
    }

    public boolean showFemaleEvents()
    {
        return showFemaleEvents;
    }

    public List<Event> filterEvents()
    {
        List<Event> filteredEvents = new ArrayList<>();

        //Resetting the person-event map so that the user and their spouse do not have missing events
        for (int i = 0; i < allPersons.size(); i++)
        {
            String personID = allPersons.get(i).getPersonID();

            getPersonEventsMap().get(personID).clear();

            for (int j = 0; j < allEvents.size(); j++)
            {
                if (allEvents.get(j).getPersonID().equals(personID))
                {
                    getPersonEventsMap().get(personID).add(allEvents.get(j));
                }
            }
        }

        if(showFathersSide() && showMothersSide())
        {
            if (showMaleEvents() && !showFemaleEvents())
            {
                filteredEvents = getMaleEvents();
            }

            else if (!showMaleEvents() && showFemaleEvents())
            {
                filteredEvents = getFemaleEvents();
            }

            else if (showMaleEvents() && showFemaleEvents())
            {
                filteredEvents = getAllEvents();
            }
        }

        else if (!showFathersSide() && showMothersSide())
        {
            filteredEvents.addAll(personEventsMap.get(userPerson.getPersonID()));

            if (userPerson.getSpouseID() != null)
            {
                filteredEvents.addAll(personEventsMap.get(userPerson.getSpouseID()));
            }

            if (showMaleEvents() && !showFemaleEvents())
            {
                filteredEvents = getMaleMaternalEvents();
            }

            else if (!showMaleEvents() && showFemaleEvents())
            {
                filteredEvents = getFemaleMaternalEvents();
            }

            else if (showMaleEvents() && showFemaleEvents())
            {
                filteredEvents.addAll(maleMaternalEvents);
                filteredEvents.addAll(femaleMaternalEvents);
            }
        }

        else if (showFathersSide() && !showMothersSide())
        {
            filteredEvents.addAll(personEventsMap.get(userPerson.getPersonID()));

            if (userPerson.getSpouseID() != null)
            {
                filteredEvents.addAll(personEventsMap.get(userPerson.getSpouseID()));
            }

            if (showMaleEvents() && !showFemaleEvents())
            {
                filteredEvents = getMalePaternalEvents();
            }

            else if (!showMaleEvents() && showFemaleEvents())
            {
                filteredEvents = getFemalePaternalEvents();
            }

            else if (showMaleEvents() && showFemaleEvents())
            {
                filteredEvents.addAll(malePaternalEvents);
                filteredEvents.addAll(femalePaternalEvents);
            }
        }

        else
        {
            if (showMaleEvents() && !showFemaleEvents())
            {
                if (userPerson.getGender().equals("m"))
                {
                    filteredEvents.addAll(personEventsMap.get(userPerson.getPersonID()));
                }

                if (personByIDMap.get(userPerson.getSpouseID()).getGender().equals("m"))
                {
                    filteredEvents.addAll(personEventsMap.get(userPerson.getSpouseID()));
                }
            }

            else if (!showMaleEvents() && showFemaleEvents())
            {
                if (userPerson.getGender().equals("f"))
                {
                    filteredEvents.addAll(personEventsMap.get(userPerson.getPersonID()));
                }

                if (personByIDMap.get(userPerson.getSpouseID()).getGender().equals("f"))
                {
                    filteredEvents.addAll(personEventsMap.get(userPerson.getSpouseID()));
                }
            }

            else if (showMaleEvents() && showFemaleEvents())
            {
                filteredEvents.addAll(personEventsMap.get(userPerson.getPersonID()));

                if (userPerson.getSpouseID() != null)
                {
                    filteredEvents.addAll(personEventsMap.get(userPerson.getSpouseID()));
                }
            }

        }

        //Modifying the person-event map to reflect the changes made
        for (int i = 0; i < allPersons.size(); i++)
        {
            String personID = allPersons.get(i).getPersonID();

            getPersonEventsMap().get(personID).clear();

            for (int j = 0; j < filteredEvents.size(); j++)
            {
                if (filteredEvents.get(j).getPersonID().equals(personID))
                {
                    getPersonEventsMap().get(personID).add(filteredEvents.get(j));
                }
            }
        }

        //Sorting the new events that were put into the map
        for (Map.Entry<String, List<Event>> entry : getPersonEventsMap().entrySet())
        {
            Collections.sort(entry.getValue(), new Comparator<Event>()
            {
                @Override
                public int compare(Event event1, Event event2)
                {
                    if (event1.getYear() == event2.getYear())
                    {
                        return Integer.valueOf(event2.getEventType().charAt(0)).compareTo(Integer.valueOf(event1.getEventType().charAt(0)));
                    }
                    else
                    {
                        return Integer.valueOf(event1.getYear()).compareTo(event2.getYear());
                    }
                }
            });
        }

        return filteredEvents;
    }

    public void populateImmediateFamily(List<Person> persons)
    {
        for (int i = 0; i < persons.size(); i++)
        {
            String personID = persons.get(i).getPersonID();

            //All checks to see if the given personID is a mother, father, spouse, etc. (determines what goes in the immediate family map)
            for (int j = 0; j < persons.size(); j++)
            {
                if (persons.get(j).getFatherID() != null && persons.get(j).getMotherID() != null)
                {
                    if (persons.get(j).getFatherID().equals(personID) || persons.get(j).getMotherID().equals(personID))
                    {
                        if (getPersonFamilyMap().containsKey(personID))
                        {
                            getPersonFamilyMap().get(personID).add(persons.get(j));
                        }
                        else
                        {
                            ArrayList<Person> personList = new ArrayList<>();
                            personList.add(persons.get(j));
                            getPersonFamilyMap().put(personID, personList);
                        }
                    }
                }

                if (persons.get(j).getPersonID().equals(persons.get(i).getSpouseID()))
                {
                    if (getPersonFamilyMap().containsKey(personID))
                    {
                        getPersonFamilyMap().get(personID).add(persons.get(j));
                    }
                    else
                    {
                        ArrayList<Person> personList = new ArrayList<>();
                        personList.add(persons.get(j));
                        getPersonFamilyMap().put(personID, personList);
                    }
                }

                if (persons.get(j).getPersonID().equals(persons.get(i).getMotherID()))
                {
                    if (getPersonFamilyMap().containsKey(personID))
                    {
                        getPersonFamilyMap().get(personID).add(persons.get(j));
                    }
                    else
                    {
                        ArrayList<Person> personList = new ArrayList<>();
                        personList.add(persons.get(j));
                        getPersonFamilyMap().put(personID, personList);
                    }
                }

                if (persons.get(j).getPersonID().equals(persons.get(i).getFatherID()))
                {
                    if (getPersonFamilyMap().containsKey(personID))
                    {
                        getPersonFamilyMap().get(personID).add(persons.get(j));
                    }
                    else
                    {
                        ArrayList<Person> personList = new ArrayList<>();
                        personList.add(persons.get(j));
                        getPersonFamilyMap().put(personID, personList);
                    }
                }
            }
        }
    }
}