/** Copyright (C) 2017 by Bundesanstalt für Gewässerkunde
 * Software engineering by
 *  Björnsen Beratende Ingenieure GmbH
 *  Dr. Schumacher Ingenieurbüro für Wasser und Umwelt
 *
 * This file is Free Software under the GNU AGPL (>=v3)
 * and comes with ABSOLUTELY NO WARRANTY! Check out the
 * documentation coming with Dive4Elements River for details.
 */
package org.dive4elements.river.artifacts.uinfo.vegetationzones;

import java.util.ArrayList;
import java.util.List;
import java.util.TreeSet;

import org.dive4elements.artifacts.CallContext;
import org.dive4elements.river.artifacts.resources.Resources;
import org.dive4elements.river.model.River;
import org.dive4elements.river.model.uinfo.VegetationType;
import org.dive4elements.river.model.uinfo.VegetationZone;

/**
 * @author Domenico Nardi Tironi
 *
 */
public class VegetationZoneServerClientXChange implements Comparable<VegetationZoneServerClientXChange> {

    // IMMER ABGLEICHEN MIT VegetationZoneServerClientXChange.class Server und Client

    private static final String TABLE_CELL_SEPARATOR = "TABLE_CELL_SEPARATOR";

    private static final String TABLE_ROW_SEPARATOR = "TABLE_ROW_SEPARATOR";

    private final String zoneName;

    private final int min_day_overflow;

    private final int max_day_overflow;

    private final String hexColor;

    public static List<VegetationZoneServerClientXChange> parse(final String zonesRaw) {
        final List<VegetationZoneServerClientXChange> resultList = new ArrayList<>();

        final List<String[]> results = new ArrayList<>();
        if (zonesRaw.contains(TABLE_ROW_SEPARATOR)) {
            final String[] rows = zonesRaw.split(TABLE_ROW_SEPARATOR);
            for (final String row : rows) {
                if (row.contains(TABLE_CELL_SEPARATOR)) {
                    final String[] result = row.split(TABLE_CELL_SEPARATOR);
                    results.add(result);
                }
            }
        }
        for (final String[] zone : results) {

            final VegetationZoneServerClientXChange helper = new VegetationZoneServerClientXChange(zone[0], Integer.valueOf(zone[1]), Integer.valueOf(zone[2]),
                    zone[3]);
            resultList.add(helper);
        }

        return resultList;
    }

    public static VegetationZoneServerClientXChange createFromTableEntry(final String zone, final String min_day_overflow, final String max_day_overflow,
            final String hexColor) {
        return new VegetationZoneServerClientXChange(zone, Integer.valueOf(min_day_overflow), Integer.valueOf(max_day_overflow), hexColor); // Error-Handling?
    }

    private VegetationZoneServerClientXChange(final String zone, final Integer min_day_overflow, final Integer max_day_overflow, final String hexColor) {
        this.zoneName = zone;
        this.min_day_overflow = min_day_overflow;
        this.max_day_overflow = max_day_overflow;
        this.hexColor = hexColor;
    }

    public int getMax_day_overflow() {
        return this.max_day_overflow;
    }

    public String getZoneName() {
        if (this.zoneName == null || this.zoneName.equals("")) {
            return "---";
        }
        return this.zoneName;
    }

    public String getHexColor() {
        try {
            // REMARK: only return valid colors
            Integer.decode(this.hexColor);
            return this.hexColor;
        }
        catch (final NumberFormatException e) {
            e.printStackTrace();
            return "#ffffff";
        }
    }

    public int getMin_day_overflow() {
        return this.min_day_overflow;
    }

    public static String getLocalizedVegetationTypeName(final CallContext context, final VegetationType zonetype) {
        return zonetype.getLocalizedName(Resources.getLocale(context.getMeta()));
    }

    public static final List<VegetationZoneServerClientXChange> getStandardList(final River river, final CallContext context) {

        final List<VegetationZoneServerClientXChange> list = new ArrayList<>();
        for (final VegetationZone vz : VegetationZone.getValues(river)) {
            final String zn = getLocalizedVegetationTypeName(context, vz.getVegetationType());
            list.add(new VegetationZoneServerClientXChange(zn, vz.getMin_overflow_days(), vz.getMax_overflow_days(), vz.getColor()));
        }
        return list;
    }

    public static final String parseListToDataString(final List<VegetationZoneServerClientXChange> list) {

        java.util.Collections.sort(list);
        final StringBuilder builder = new StringBuilder();
        for (final VegetationZoneServerClientXChange zone : list) {
            builder.append(zone.getZoneName());
            builder.append(TABLE_CELL_SEPARATOR);
            builder.append(zone.getMin_day_overflow());
            builder.append(TABLE_CELL_SEPARATOR);
            builder.append(zone.getMax_day_overflow());
            builder.append(TABLE_CELL_SEPARATOR);
            builder.append(zone.getHexColor());
            builder.append(TABLE_ROW_SEPARATOR);
        }
        return builder.toString();

    }

    @Override
    public int compareTo(final VegetationZoneServerClientXChange o) {
        final int basicCompare = Integer.valueOf(this.getMin_day_overflow()).compareTo(o.getMin_day_overflow());
        if (basicCompare == 0)
            return Integer.valueOf(this.getMax_day_overflow()).compareTo(o.getMax_day_overflow()); // wenn min==min && max==max, alphabetisch sortieren?

        if (basicCompare == 0) {
            return 1; // for treeSet
        }

        return basicCompare;
    }

    public static final boolean zonesAreOverlapping(final List<VegetationZoneServerClientXChange> list) {
        for (final VegetationZoneServerClientXChange zone : list) {
            for (final VegetationZoneServerClientXChange zoneOther : list) {
                if (zone != zoneOther) {
                    final boolean overlaps = zone.overlaps(zoneOther);
                    if (overlaps) {
                        return overlaps; // cancel. only one zone has to overlap
                    }
                }
            }
        }

        return false;
    }

    public static final boolean hasGaps(final List<VegetationZoneServerClientXChange> list, final int lower, final int upper) {

        if ((upper - lower) == 0)
            return true;

        final TreeSet<VegetationZoneServerClientXChange> treeList = new TreeSet<>();
        treeList.addAll(list);
        int lowerCompare = lower;
        for (final VegetationZoneServerClientXChange zone : treeList) {
            if (zone.getLowerFromTo() > (lowerCompare)) { // nicht inklusiv
                return true;
            }
            lowerCompare = zone.getUpperFromTo();
        }
        if ((lowerCompare) < upper)
            return true; // am Ende nicht geschlossen

        return false;
    }

    private boolean overlaps(final VegetationZoneServerClientXChange otherZone) {
        final int otherLower = otherZone.getLowerFromTo();
        final int otherUpper = otherZone.getUpperFromTo();

        final int upper = getUpperFromTo();
        final int lower = getLowerFromTo();
        if ((otherUpper <= upper && otherUpper > lower)) {
            return true;
        } else if (otherLower >= lower && otherLower < upper) {
            return true;
        } else if (otherLower == lower && otherUpper == upper) {
            return true;
        }
        return false;
    }

    public Integer getLowerFromTo() {
        return this.min_day_overflow < this.max_day_overflow ? this.min_day_overflow : this.max_day_overflow; // Math. is forbidden :-(
    }

    public Integer getUpperFromTo() {
        return this.min_day_overflow > this.max_day_overflow ? this.min_day_overflow : this.max_day_overflow;// Math. is forbidden :-(
    }
}