/*
 * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
 * Copyright (C) $$Year-Rel$$ The Jalview Authors
 * 
 * This file is part of Jalview.
 * 
 * Jalview 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.
 *  
 * Jalview 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 Jalview.  If not, see <http://www.gnu.org/licenses/>.
 * The Jalview Authors are detailed in the 'AUTHORS' file.
 */
package jalview.ws.params.simple;

import jalview.ws.params.ParameterI;
import jalview.ws.params.ValueConstrainI;
import static java.util.Objects.requireNonNullElse;

/**
 * @author jimp
 * 
 */
public class IntegerParameter extends Option implements ParameterI
{
  public static class Builder extends Option.Builder
  {
    // assigning them the opposite way results in no limits unless both are set
    protected int min = Integer.MAX_VALUE;

    protected int max = Integer.MIN_VALUE;

    @Override
    public void setDefaultValue(String defaultValue)
    {
      throw new UnsupportedOperationException();
    }

    public void setDefaultValue(Integer defaultValue)
    {
      if (defaultValue != null)
        super.setDefaultValue(defaultValue.toString());
      else
        super.setDefaultValue(null);
    }

    @Override
    public void setValue(String value)
    {
      throw new UnsupportedOperationException();
    }

    public void setValue(Integer value)
    {
      if (value != null)
        super.setValue(value.toString());
      else
        super.setValue(null);
    }

    public void setMin(Integer min)
    {
      this.min = requireNonNullElse(min, Integer.MAX_VALUE);
    }

    public void setMax(Integer max)
    {
      this.max = requireNonNullElse(max, Integer.MIN_VALUE);
    }

    public void setBounds(Integer min, Integer max)
    {
      setMin(min);
      setMax(max);
    }

    public IntegerParameter build()
    {
      return new IntegerParameter(this);
    }
  }

  public static Builder newBuilder()
  {
    return new Builder();
  }

  int defval;

  int min;

  int max;

  @Override
  public ValueConstrainI getValidValue()
  {
    return new ValueConstrainI()
    {

      @Override
      public ValueType getType()
      {
        return ValueType.Integer;
      }

      @Override
      public Number getMin()
      {
        return min < max ? min : null;
      }

      @Override
      public Number getMax()
      {
        return min < max ? max : null;
      }
    };
  }

  protected IntegerParameter(Builder builder)
  {
    super(builder);
    min = builder.min;
    max = builder.max;
    if (defvalue != null)
      defval = Integer.parseInt(defvalue);
  }

  public IntegerParameter(IntegerParameter parm)
  {
    super(parm);
    max = parm.max;
    min = parm.min;
  }

  public IntegerParameter(String name, String description, boolean required,
      int defValue, int min, int max)
  {
    super(name, description, required, String.valueOf(defValue), null, null,
        null);
    defval = defValue;
    this.min = min;
    this.max = max;
  }

  public IntegerParameter(String name, String description, boolean required,
      int defValue, int value, int min, int max)
  {
    super(name, description, required, String.valueOf(defValue),
        String.valueOf(value), null, null);
    defval = defValue;
    this.min = min;
    this.max = max;
  }

  @Override
  public IntegerParameter copy()
  {
    return new IntegerParameter(this);
  }

}