package jalview.bin.argparser;

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

import jalview.bin.Console;
import jalview.bin.argparser.Arg.Opt;

public class ArgValues
{
  public static final String ID = "id";

  private Arg arg;

  private int argCount = 0;

  private boolean boolValue = false;

  private boolean negated = false;

  private int boolIndex = -1;

  private List<Integer> argsIndexes;

  private List<ArgValue> argValueList;

  private Map<String, ArgValue> idMap = new HashMap<>();

  protected ArgValues(Arg a)
  {
    this.arg = a;
    this.argValueList = new ArrayList<ArgValue>();
    this.boolValue = arg.getDefaultBoolValue();
  }

  public Arg arg()
  {
    return arg;
  }

  protected int getCount()
  {
    return argCount;
  }

  protected void incrementCount()
  {
    argCount++;
  }

  protected void setNegated(boolean b)
  {
    this.negated = b;
  }

  protected boolean isNegated()
  {
    return this.negated;
  }

  protected void setBoolean(boolean b, int i)
  {
    this.boolValue = b;
    this.boolIndex = i;
  }

  protected boolean getBoolean()
  {
    return this.boolValue;
  }

  @Override
  public String toString()
  {
    if (argValueList == null)
      return null;
    StringBuilder sb = new StringBuilder();
    sb.append(arg.toLongString());
    if (arg.hasOption(Opt.BOOLEAN) || arg.hasOption(Opt.UNARY))
      sb.append("Boolean: ").append(boolValue).append("; Default: ")
              .append(arg.getDefaultBoolValue()).append("; Negated: ")
              .append(negated).append("\n");
    if (arg.hasOption(Opt.STRING))
    {
      sb.append("Values:");
      sb.append("'")
              .append(String
                      .join("',\n  '",
                              argValueList.stream().map(av -> av.getValue())
                                      .collect(Collectors.toList())))
              .append("'");
      sb.append("\n");
    }
    sb.append("Count: ").append(argCount).append("\n");
    return sb.toString();
  }

  protected void addValue()
  {
    addValue(null, -1);
  }

  protected void addValue(String val, int argIndex)
  {
    addArgValue(new ArgValue(val, argIndex));
  }

  protected void addValue(SubVals sv, String content, int argIndex)
  {
    addArgValue(new ArgValue(sv, content, argIndex));
  }

  protected void addArgValue(ArgValue av)
  {
    if ((!arg.hasOption(Opt.MULTI) && argValueList.size() > 0)
            || (arg.hasOption(Opt.NODUPLICATEVALUES)
                    && argValueList.contains(av.getValue())))
      return;
    if (argValueList == null)
    {
      argValueList = new ArrayList<ArgValue>();
    }
    SubVals sv = ArgParser.getSubVals(av.getValue());
    if (sv.has(ID))
    {
      String id = sv.get(ID);
      av.setId(id);
      idMap.put(id, av);
    }
    argValueList.add(av);
  }

  protected boolean hasValue(String val)
  {
    return argValueList.contains(val);
  }

  protected ArgValue getArgValue()
  {
    if (arg.hasOption(Opt.MULTI))
      Console.warn("Requesting single value for multi value argument");
    return argValueList.size() > 0 ? argValueList.get(0) : null;
  }

  protected List<ArgValue> getArgValueList()
  {
    return argValueList;
  }

  protected boolean hasId(String id)
  {
    return idMap.containsKey(id);
  }

  protected ArgValue getId(String id)
  {
    return idMap.get(id);
  }
}