////////////////////////////////////////////////////////////////////////////////////////////////////
// PlotSquared - A plot manager and world generator for the Bukkit API                             /
// Copyright (c) 2014 IntellectualSites/IntellectualCrafters                                       /
//                                                                                                 /
// This program is free software; you can redistribute it and/or modify                            /
// it under the terms of the GNU General Public License as published by                            /
// the Free Software Foundation; either version 3 of the License, or                               /
// (at your option) any later version.                                                             /
//                                                                                                 /
// This program is distributed in the hope that it will be useful,                                 /
// but WITHOUT ANY WARRANTY; without even the implied warranty of                                  /
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                   /
// GNU General Public License for more details.                                                    /
//                                                                                                 /
// You should have received a copy of the GNU General Public License                               /
// along with this program; if not, write to the Free Software Foundation,                         /
// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA                               /
//                                                                                                 /
// You can contact us via: support@intellectualsites.com                                           /
////////////////////////////////////////////////////////////////////////////////////////////////////
package com.intellectualcrafters.plot.flag;

import com.intellectualcrafters.plot.PS;
import com.intellectualcrafters.plot.config.C;
import com.intellectualcrafters.plot.database.DBFunc;
import com.intellectualcrafters.plot.object.Plot;
import com.intellectualcrafters.plot.object.PlotArea;
import com.intellectualcrafters.plot.object.PlotCluster;
import com.intellectualcrafters.plot.object.PlotPlayer;
import com.intellectualcrafters.plot.object.PlotSettings;
import com.intellectualcrafters.plot.object.RunnableVal;
import com.intellectualcrafters.plot.util.EventUtil;
import com.intellectualcrafters.plot.util.Permissions;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * Flag Manager Utility
 *


 */
public class FlagManager {
    
    private final static HashSet<String> reserved = new HashSet<>();
    
    private final static HashSet<AbstractFlag> flags = new HashSet<>();
    
    /**
     * Reserve a flag so that it cannot be set by players
     * @param flag
     */
    public static void reserveFlag(final String flag) {
        reserved.add(flag);
    }
    
    /**
     * Get if a flag is reserved
     * @param flag
     * @return
     */
    public static boolean isReserved(final String flag) {
        return reserved.contains(flag);
    }
    
    /**
     * Get the reserved flags
     * @return
     */
    public static HashSet<String> getReservedFlags() {
        return (HashSet<String>) reserved.clone();
    }
    
    /**
     * Unreserve a flag
     * @param flag
     */
    public static void unreserveFlag(final String flag) {
        reserved.remove(flag);
    }
    
    /**
     * Register an AbstractFlag with PlotSquared
     *
     * @param af Flag to register
     *
     * @return boolean success
     */
    public static boolean addFlag(final AbstractFlag af) {
        return addFlag(af, false);
    }
    
    public static boolean addFlag(final AbstractFlag af, final boolean reserved) {
        PS.debug(C.PREFIX.s() + "&8 - Adding flag: &7" + af);
        PS.get().foreachPlotArea(new RunnableVal<PlotArea>() {
            @Override
            public void run(PlotArea value) {
                final Flag flag = value.DEFAULT_FLAGS.get(af.getKey());
                if (flag != null) {
                    flag.setKey(af);
                }
            }
        });
        PS.get().foreachPlotRaw(new RunnableVal<Plot>() {
            @Override
            public void run(Plot value) {
                final Flag flag = value.getFlags().get(af.getKey());
                if (flag != null) {
                    flag.setKey(af);
                }
            }
        });
        if (flags.remove(af)) {
            PS.debug("(Replaced existing flag)");
        }
        flags.add(af);
        if (reserved) {
            reserveFlag(af.getKey());
        }
        return false;
    }
    
    public static Flag getSettingFlag(final PlotArea area, final PlotSettings settings, final String id) {
        Flag flag;
        if (settings.flags.isEmpty() || (flag = settings.flags.get(id)) == null) {
            if (area == null) {
                return null;
            }
            if (area.DEFAULT_FLAGS.isEmpty()) {
                return null;
            }
            return area.DEFAULT_FLAGS.get(id);
        }
        return flag;
    }
    
    public static boolean isBooleanFlag(final Plot plot, final String key, final boolean defaultValue) {
        final Flag flag = FlagManager.getPlotFlagRaw(plot, key);
        if (flag == null) {
            return defaultValue;
        }
        final Object value = flag.getValue();
        if (value instanceof Boolean) {
            return (boolean) value;
        }
        return defaultValue;
    }
    
    /**
     * Get the value of a flag for a plot (respects flag defaults)
     * @param plot
     * @param flag
     * @return Flag
     */
    public static Flag getPlotFlag(final Plot plot, final String flag) {
        Flag result = getPlotFlagRaw(plot, flag);
        return result == null ? null : (Flag) result.clone();
    }

    /**
     * Returns the raw flag<br>
     *  - Faster
     *  - You should not modify the flag
     * @param plot
     * @param flag
     * @return
     */
    public static Flag getPlotFlagRaw(final Plot plot, final String flag) {
        if (plot.owner == null) {
            return null;
        }
        return getSettingFlag(plot.getArea(), plot.getSettings(), flag);
    }
    
    public static boolean isPlotFlagTrue(final Plot plot, final String strFlag) {
        if (plot.owner == null) {
            return false;
        }
        final Flag flag = getPlotFlagRaw(plot, strFlag);
        return !(flag == null || !((Boolean) flag.getValue()));
    }
    
    public static boolean isPlotFlagFalse(final Plot plot, final String strFlag) {
        if (plot.owner == null) {
            return false;
        }
        final Flag flag = getPlotFlagRaw(plot, strFlag);
        if (flag == null || (Boolean) flag.getValue()) {
            return false;
        }
        return false;
    }
    
    /**
     * Get the value of a flag for a plot (ignores flag defaults)
     * @param plot
     * @param flag
     * @return Flag
     */
    public static Flag getPlotFlagAbs(final Plot plot, final String flag) {
        return getSettingFlagAbs(plot.getSettings(), flag);
    }
    
    public static Flag getSettingFlagAbs(final PlotSettings settings, final String flag) {
        if (settings.flags == null || settings.flags.isEmpty()) {
            return null;
        }
        return settings.flags.get(flag);
    }
    
    /**
     * Add a flag to a plot
     * @param origin
     * @param flag
     */
    public static boolean addPlotFlag(final Plot origin, final Flag flag) {
        final boolean result = EventUtil.manager.callFlagAdd(flag, origin);
        if (!result) {
            return false;
        }
        for (Plot plot : origin.getConnectedPlots()) {
            plot.getFlags().put(flag.getKey(), flag);
            plot.reEnter();
            DBFunc.setFlags(plot, plot.getFlags().values());
        }
        return true;
    }
    
    public static boolean addPlotFlagAbs(final Plot plot, final Flag flag) {
        final boolean result = EventUtil.manager.callFlagAdd(flag, plot);
        if (!result) {
            return false;
        }
        plot.getFlags().put(flag.getKey(), flag);
        return true;
    }
    
    public static boolean addClusterFlag(final PlotCluster cluster, final Flag flag) {
        getSettingFlag(cluster.area, cluster.settings, flag.getKey());
        cluster.settings.flags.put(flag.getKey(), flag);
        DBFunc.setFlags(cluster, cluster.settings.flags.values());
        return true;
    }
    
    /**
     *
     * @param plot
     * @return set of flags
     */
    public static HashMap<String, Flag> getPlotFlags(final Plot plot) {
        if (!plot.hasOwner()) {
            return null;
        }
        return getSettingFlags(plot.getArea(), plot.getSettings());
    }
    
    public static HashMap<String, Flag> getPlotFlags(PlotArea area, final PlotSettings settings, final boolean ignorePluginflags) {
        final HashMap<String, Flag> flags = new HashMap<>();
        if (area != null && !area.DEFAULT_FLAGS.isEmpty()) {
            flags.putAll(area.DEFAULT_FLAGS);
        }
        if (ignorePluginflags) {
            for (final Map.Entry<String, Flag> flag : settings.flags.entrySet()) {
                if (isReserved(flag.getValue().getAbstractFlag().getKey())) {
                    continue;
                }
                flags.put(flag.getKey(), flag.getValue());
            }
        } else {
            flags.putAll(settings.flags);
        }
        
        return flags;
    }
    
    public static HashMap<String, Flag> getSettingFlags(PlotArea area, final PlotSettings settings) {
        return getPlotFlags(area, settings, false);
    }
    
    public static boolean removePlotFlag(final Plot plot, final String id) {
        final Flag flag = plot.getFlags().remove(id);
        if (flag == null) {
            return false;
        }
        final boolean result = EventUtil.manager.callFlagRemove(flag, plot);
        if (!result) {
            plot.getFlags().put(id, flag);
            return false;
        }
        plot.reEnter();
        DBFunc.setFlags(plot, plot.getFlags().values());
        return true;
    }
    
    public static boolean removeClusterFlag(final PlotCluster cluster, final String id) {
        final Flag flag = cluster.settings.flags.remove(id);
        if (flag == null) {
            return false;
        }
        final boolean result = EventUtil.manager.callFlagRemove(flag, cluster);
        if (!result) {
            cluster.settings.flags.put(id, flag);
            return false;
        }
        DBFunc.setFlags(cluster, cluster.settings.flags.values());
        return true;
    }
    
    public static void setPlotFlags(final Plot origin, final Set<Flag> flags) {
        for (Plot plot : origin.getConnectedPlots()) {
            if (flags != null && !flags.isEmpty()) {
                plot.getFlags().clear();
                for (final Flag flag : flags) {
                    plot.getFlags().put(flag.getKey(), flag);
                }
            } else if (plot.getFlags().isEmpty()) {
                return;
            } else {
                plot.getFlags().clear();
            }
            plot.reEnter();
            DBFunc.setFlags(plot, plot.getFlags().values());
        }
    }
    
    public static void setClusterFlags(final PlotCluster cluster, final Set<Flag> flags) {
        if (flags != null && !flags.isEmpty()) {
            cluster.settings.flags.clear();
            for (final Flag flag : flags) {
                cluster.settings.flags.put(flag.getKey(), flag);
            }
        } else if (cluster.settings.flags.isEmpty()) {
            return;
        } else {
            cluster.settings.flags.clear();
        }
        DBFunc.setFlags(cluster, cluster.settings.flags.values());
    }
    
    public static Flag[] removeFlag(final Flag[] flags, final String r) {
        final Flag[] f = new Flag[flags.length - 1];
        int index = 0;
        for (final Flag flag : flags) {
            if (!flag.getKey().equals(r)) {
                f[index++] = flag;
            }
        }
        return f;
    }
    
    public static Set<Flag> removeFlag(final Set<Flag> flags, final String r) {
        final HashSet<Flag> newflags = new HashSet<>();
        for (final Flag flag : flags) {
            if (!flag.getKey().equalsIgnoreCase(r)) {
                newflags.add(flag);
            }
        }
        return newflags;
    }
    
    /**
     * Get a list of registered AbstractFlag objects
     *
     * @return List (AbstractFlag)
     */
    public static HashSet<AbstractFlag> getFlags() {
        return flags;
    }
    
    /**
     * Get a list of registered AbstractFlag objects based on player permissions
     *
     * @param player with permissions
     *
     * @return List (AbstractFlag)
     */
    public static List<AbstractFlag> getFlags(final PlotPlayer player) {
        final List<AbstractFlag> returnFlags = new ArrayList<>();
        for (final AbstractFlag flag : flags) {
            if (Permissions.hasPermission(player, "plots.set.flag." + flag.getKey().toLowerCase())) {
                returnFlags.add(flag);
            }
        }
        return returnFlags;
    }
    
    /**
     * Get an AbstractFlag by a string Returns null if flag does not exist
     *
     * @param string Flag Key
     *
     * @return AbstractFlag
     */
    public static AbstractFlag getFlag(final String string) {
        for (final AbstractFlag flag : flags) {
            if (flag.getKey().equalsIgnoreCase(string)) {
                return flag;
            }
        }
        return null;
    }
    
    /**
     * Get an AbstractFlag by a string
     *
     * @param string Flag Key
     * @param create If to create the flag if it does not exist
     *
     * @return AbstractFlag
     */
    public static AbstractFlag getFlag(final String string, final boolean create) {
        if (getFlag(string) == null && create) {
            return new AbstractFlag(string);
        }
        return getFlag(string);
    }
    
    /**
     * Remove a registered AbstractFlag
     *
     * @param flag Flag Key
     *
     * @return boolean Result of operation
     */
    public static boolean removeFlag(final AbstractFlag flag) {
        return flags.remove(flag);
    }
    
    public static HashMap<String, Flag> parseFlags(final List<String> flagstrings) {
        final HashMap<String, Flag> map = new HashMap<>();
        for (final String key : flagstrings) {
            final String[] split;
            if (key.contains(";")) {
                split = key.split(";");
            } else {
                split = key.split(":");
            }
            Flag flag;
            if (split.length == 1) {
                flag = new Flag(getFlag(split[0], true), "");
            } else {
                flag = new Flag(getFlag(split[0], true), split[1]);
            }
            map.put(flag.getKey(), flag);
        }
        return map;
    }
}