package org.poopki.duckdns.user_db.Array;

import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import org.poopki.duckdns.user_db.UserInfoArray;

import java.util.*;

public class GroupArray {


    protected Map<UUID, Group> m_GroupArray;
    protected Map<String, UUID> m_GroupNameList;
    public List<UUID> m_DeleteQueue = new ArrayList<>();
    UserInfoArray m_UserInfoArray;
    UUID ZERO_UUID = UUID.fromString("00000000-0000-0000-0000-000000000000");
    int MAX_GROUP_NUM = 10;

    public GroupArray(UserInfoArray m_UIA, int num){
        m_UserInfoArray = m_UIA;
        m_GroupArray = new HashMap<UUID, Group>();
        m_GroupNameList = new HashMap<String, UUID>();
        MAX_GROUP_NUM = num;
    }

    public boolean CreateGroup(UUID GroupUUID, String Name, UUID PlayerUUID){
        if(m_GroupNameList.containsKey(Name)){
            return false; // Conflict
        } else{
            List<UUID> m_MemberList = new ArrayList<>();
            m_MemberList.add(PlayerUUID);

            m_GroupArray.put(GroupUUID, new Group(Name, m_MemberList));
            m_GroupNameList.put(Name, GroupUUID);
            return true;
        }
    }

    public boolean PutGroup(UUID GroupUUID, String Name,List<UUID> PlayerUUID){
        List<UUID> m_MemberList = new ArrayList<>();

        Iterator <UUID> it = PlayerUUID.iterator();

        while(it.hasNext()){
            m_MemberList.add(it.next());
        }

        m_GroupArray.put(GroupUUID, new Group(Name, m_MemberList));
        m_GroupNameList.put(Name,GroupUUID);
        return true;
    }

    public boolean CheckGroup(String GroupType, String Name){
        return m_GroupArray.containsKey(m_GroupNameList.get(Name));
    }
    public static <K, V> K getKey(Map<K, V> map, V value) {

        for (K key : map.keySet()) {
            if (value.equals(map.get(key))) {
                return key;
            }
        }
        return null;
    }

    public UUID GetUUID(String name){
        return m_GroupNameList.get(name);
    }

    public boolean DeleteGroup(UUID GroupUUID, String GroupType){
        if(m_GroupArray.containsKey(GroupUUID)){
            for(UUID key: GetGroupMembersUUID(GroupUUID)){
                m_UserInfoArray.setUserGroupUUID(GroupType,key,new UUID(0,0));
            }

            m_GroupNameList.remove(GetGroupName(GroupUUID));
            m_GroupArray.remove(GroupUUID);
            return true;
        }
        else{
            return false; // Group is not exists.
        }

    }

    public Integer SignUpGroup(String GroupType, UUID GroupUUID, UUID PlayerUUID){
        if(m_GroupArray.containsKey(GroupUUID) & !m_UserInfoArray.getUserGroupUUID(PlayerUUID, GroupType).equals(ZERO_UUID)){

            Group m_Group = m_GroupArray.get(GroupUUID);
            m_Group.SignUp(PlayerUUID);
            m_UserInfoArray.setUserGroupUUID(GroupType,PlayerUUID,GroupUUID);

        } else{
            return 3; // Wrong Group
        }
        return 0;
    }

    public boolean ExpulsionGroupPlayer(String GroupType, UUID GroupUUID, UUID PlayerUUID){
        if(m_GroupArray.get(GroupUUID).isMember(PlayerUUID)) {
            Group m_Group = m_GroupArray.get(GroupUUID);
            m_Group.Expulsion(PlayerUUID);
            m_UserInfoArray.setUserGroupUUID(GroupType,PlayerUUID,ZERO_UUID);
            int temp = m_GroupArray.get(GroupUUID).getMemNUM();

            if(temp==0){
                m_GroupNameList.remove(m_Group.getGroupName());
                m_GroupArray.remove(GroupUUID);
                m_DeleteQueue.add(GroupUUID);
                Bukkit.getPlayer(PlayerUUID).sendMessage(""+temp+" "+m_DeleteQueue);
            }
            return true;
        } else{
            return false; // Wrong Player Name. FIXME{Need Checking function for a validate user name's }
            /* Player op = Bukkit.getPlayer(args[1]);
                            if (op != null) {
            */
        }
    }

    public List<String> GetGroupMembersName(UUID GroupUUID){
        List<String> MembersName = new ArrayList<>();
        for (UUID key : m_GroupArray.get(GroupUUID).getGroupMembers()){
            try {
                MembersName.add(Bukkit.getPlayer(key).getDisplayName());
            }
            catch(NullPointerException e){

            }
        }
        return MembersName;
    }
    public List<UUID> GetGroupMembersUUID(UUID GroupUUID){
        return m_GroupArray.get(GroupUUID).getGroupMembers();
    }
    public boolean isGroupMember(UUID GroupUUID, UUID PlayerUUID){
        Group m_Group = m_GroupArray.get(GroupUUID);
        return m_Group.isMember(PlayerUUID);
    }
    public int GetGroupMemNUM(UUID GroupUUID){
        Group m_Group = m_GroupArray.get(GroupUUID);
        return m_Group.getMemNUM();
    }
    public Set<String> GetGroupNameList(){
        return m_GroupNameList.keySet();
    }

    public Set<UUID> getKeySet(){ // 유저 목록 return
        return m_GroupArray.keySet();
    }

    public Set<String> getNameSet() { return m_GroupNameList.keySet(); }
    public String GetGroupName(UUID GroupUUID){
        Group m_Group = m_GroupArray.get(GroupUUID);
        return m_Group.getGroupName();
    }
    public int GetGroupMemMaxNum(UUID GroupUUID){
        Group m_Group = m_GroupArray.get(GroupUUID);
        return m_Group.getMemMaxNUM();
    }
    public boolean isOffline(UUID uuid){
        return Bukkit.getPlayer(uuid).equals(null) && !Bukkit.getOfflinePlayer(uuid).equals(null);
    }

    public boolean isOwner(UUID GroupUUID, UUID PlayerUUID){
        return m_GroupArray.get(GroupUUID).isOwner(PlayerUUID);
    }
    private boolean isAvaliableGroup(UUID GroupUUID){
        return m_GroupArray.containsKey(GroupUUID);
    }

}