/*
 * Copyright (c) 2011-2019 Contributors to the Eclipse Foundation
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0
 * which is available at https://www.apache.org/licenses/LICENSE-2.0.
 *
 * SPDX-License-Identifier: EPL-2.0 OR Apache-2.0
 */

package io.vertx.core.http;

import io.netty.handler.codec.http2.Http2CodecUtil;
import io.vertx.codegen.annotations.DataObject;
import io.vertx.codegen.annotations.GenIgnore;
import io.vertx.core.impl.Arguments;
import io.vertx.core.json.JsonObject;

import java.util.HashMap;
import java.util.Map;

HTTP2 settings, the settings is initialized with the default HTTP/2 values.

The settings expose the parameters defined by the HTTP/2 specification, as well as extra settings for
protocol extensions.
Author:
Julien Viet/**
 * HTTP2 settings, the settings is initialized with the default HTTP/2 values.<p>
 *
 * The settings expose the parameters defined by the HTTP/2 specification, as well as extra settings for
 * protocol extensions.
 *
 * @author <a href="mailto:julien@julienviet.com">Julien Viet</a>
 */
@DataObject(generateConverter = true, publicConverter = false)
public class Http2Settings {

  
Default HTTP/2 spec value for getHeaderTableSize : 4096 /**
   * Default HTTP/2 spec value for {@link #getHeaderTableSize} : {@code 4096}
   */
  public static final long DEFAULT_HEADER_TABLE_SIZE = 4096;

  
Default HTTP/2 spec value for isPushEnabled : true /**
   * Default HTTP/2 spec value for {@link #isPushEnabled} : {@code true}
   */
  public static final boolean DEFAULT_ENABLE_PUSH = true;

  
Default HTTP/2 spec value for getMaxConcurrentStreams : 0xFFFFFFFFL /**
   * Default HTTP/2 spec value for {@link #getMaxConcurrentStreams} : {@code 0xFFFFFFFFL}
   */
  public static final long DEFAULT_MAX_CONCURRENT_STREAMS = 0xFFFFFFFFL;

  
Default HTTP/2 spec value for getInitialWindowSize : 65535 /**
   * Default HTTP/2 spec value for {@link #getInitialWindowSize} : {@code 65535}
   */
  public static final int DEFAULT_INITIAL_WINDOW_SIZE = 65535;

  
Default HTTP/2 spec value for getMaxFrameSize : 16384 /**
   * Default HTTP/2 spec value for {@link #getMaxFrameSize} : {@code 16384}
   */
  public static final int DEFAULT_MAX_FRAME_SIZE = 16384;

  
Default HTTP/2 spec value for getMaxHeaderListSize : Integer.MAX_VALUE /**
   * Default HTTP/2 spec value for {@link #getMaxHeaderListSize} : {@code Integer.MAX_VALUE}
   */
  public static final int DEFAULT_MAX_HEADER_LIST_SIZE = Integer.MAX_VALUE;

  
Default HTTP/2 spec value for getExtraSettings : null /**
   * Default HTTP/2 spec value for {@link #getExtraSettings} : {@code null}
   */
  public static final Map<Integer, Long> DEFAULT_EXTRA_SETTINGS = null;

  private long headerTableSize;
  private boolean pushEnabled;
  private long maxConcurrentStreams;
  private int initialWindowSize;
  private int maxFrameSize;
  private long maxHeaderListSize;
  private Map<Integer, Long> extraSettings;

  
Default constructor
/**
   * Default constructor
   */
  public Http2Settings() {
    headerTableSize = DEFAULT_HEADER_TABLE_SIZE;
    pushEnabled = DEFAULT_ENABLE_PUSH;
    maxConcurrentStreams = DEFAULT_MAX_CONCURRENT_STREAMS;
    initialWindowSize = DEFAULT_INITIAL_WINDOW_SIZE;
    maxFrameSize = DEFAULT_MAX_FRAME_SIZE;
    maxHeaderListSize = DEFAULT_MAX_HEADER_LIST_SIZE;
    extraSettings = DEFAULT_EXTRA_SETTINGS;
  }

  
Create an settings from JSON
Params:
json – the JSON/**
   * Create an settings from JSON
   *
   * @param json the JSON
   */
  public Http2Settings(JsonObject json) {
    this();
    Http2SettingsConverter.fromJson(json, this);
  }

  
Copy constructor
Params:
other – the settings to copy/**
   * Copy constructor
   *
   * @param other the settings to copy
   */
  public Http2Settings(Http2Settings other) {
    headerTableSize = other.headerTableSize;
    pushEnabled = other.pushEnabled;
    maxConcurrentStreams = other.maxConcurrentStreams;
    initialWindowSize = other.initialWindowSize;
    maxFrameSize = other.maxFrameSize;
    maxHeaderListSize = other.maxHeaderListSize;
    extraSettings = other.extraSettings != null ? new HashMap<>(other.extraSettings) : null;
  }

  
Returns:
the SETTINGS_HEADER_TABLE_SIZE HTTP/2 setting/**
   * @return the {@literal SETTINGS_HEADER_TABLE_SIZE} HTTP/2 setting
   */
  public long getHeaderTableSize() {
    return headerTableSize;
  }

  
Set SETTINGS_HEADER_TABLE_SIZE HTTP/2 setting. 
Params:
headerTableSize – the new value
Returns:
a reference to this, so the API can be used fluently/**
   * Set {@literal SETTINGS_HEADER_TABLE_SIZE} HTTP/2 setting.
   *
   * @param headerTableSize the new value
   * @return a reference to this, so the API can be used fluently
   */
  public Http2Settings setHeaderTableSize(long headerTableSize) {
    Arguments.require(headerTableSize >= Http2CodecUtil.MIN_HEADER_TABLE_SIZE,
        "headerTableSize must be >= " + Http2CodecUtil.MIN_HEADER_TABLE_SIZE);
    Arguments.require(headerTableSize <= Http2CodecUtil.MAX_HEADER_TABLE_SIZE,
        "headerTableSize must be <= " + Http2CodecUtil.MAX_HEADER_TABLE_SIZE);
    this.headerTableSize = headerTableSize;
    return this;
  }

  
Returns:
the SETTINGS_ENABLE_PUSH HTTP/2 setting/**
   * @return the {@literal SETTINGS_ENABLE_PUSH} HTTP/2 setting
   */
  public boolean isPushEnabled() {
    return pushEnabled;
  }

  
Set the SETTINGS_ENABLE_PUSH HTTP/2 setting 
Params:
pushEnabled – the new value
Returns:
a reference to this, so the API can be used fluently/**
   * Set the {@literal SETTINGS_ENABLE_PUSH} HTTP/2 setting
   *
   * @param pushEnabled the new value
   * @return a reference to this, so the API can be used fluently
   */
  public Http2Settings setPushEnabled(boolean pushEnabled) {
    this.pushEnabled = pushEnabled;
    return this;
  }

  
Returns:
the SETTINGS_MAX_CONCURRENT_STREAMS HTTP/2 setting/**
   * @return the {@literal SETTINGS_MAX_CONCURRENT_STREAMS} HTTP/2 setting
   */
  public long getMaxConcurrentStreams() {
    return maxConcurrentStreams;
  }

  
Set the SETTINGS_MAX_CONCURRENT_STREAMS HTTP/2 setting 
Params:
maxConcurrentStreams – the new value
Returns:
a reference to this, so the API can be used fluently/**
   * Set the {@literal SETTINGS_MAX_CONCURRENT_STREAMS} HTTP/2 setting
   *
   * @param maxConcurrentStreams the new value
   * @return a reference to this, so the API can be used fluently
   */
  public Http2Settings setMaxConcurrentStreams(long maxConcurrentStreams) {
    Arguments.require(maxConcurrentStreams >= Http2CodecUtil.MIN_CONCURRENT_STREAMS,
        "maxConcurrentStreams must be >= " + Http2CodecUtil.MIN_CONCURRENT_STREAMS);
    Arguments.require(maxConcurrentStreams <= Http2CodecUtil.MAX_CONCURRENT_STREAMS,
        "maxConcurrentStreams must be < " + Http2CodecUtil.MAX_CONCURRENT_STREAMS);
    this.maxConcurrentStreams = maxConcurrentStreams;
    return this;
  }

  
Returns:
the SETTINGS_INITIAL_WINDOW_SIZE HTTP/2 setting/**
   * @return the {@literal SETTINGS_INITIAL_WINDOW_SIZE} HTTP/2 setting
   */
  public int getInitialWindowSize() {
    return initialWindowSize;
  }

  
Set the SETTINGS_INITIAL_WINDOW_SIZE HTTP/2 setting 
Params:
initialWindowSize – the new value
Returns:
a reference to this, so the API can be used fluently/**
   * Set the {@literal SETTINGS_INITIAL_WINDOW_SIZE} HTTP/2 setting
   *
   * @param initialWindowSize the new value
   * @return a reference to this, so the API can be used fluently
   */
  public Http2Settings setInitialWindowSize(int initialWindowSize) {
    Arguments.require(initialWindowSize >= Http2CodecUtil.MIN_INITIAL_WINDOW_SIZE,
        "initialWindowSize must be >= " + Http2CodecUtil.MIN_INITIAL_WINDOW_SIZE);
    this.initialWindowSize = initialWindowSize;
    return this;
  }

  
Returns:
the SETTINGS_MAX_FRAME_SIZE HTTP/2 setting/**
   * @return the {@literal SETTINGS_MAX_FRAME_SIZE} HTTP/2 setting
   */
  public int getMaxFrameSize() {
    return maxFrameSize;
  }

  
Set the SETTINGS_MAX_FRAME_SIZE HTTP/2 setting 
Params:
maxFrameSize – the new value
Returns:
a reference to this, so the API can be used fluently/**
   * Set the {@literal SETTINGS_MAX_FRAME_SIZE} HTTP/2 setting
   *
   * @param maxFrameSize the new value
   * @return a reference to this, so the API can be used fluently
   */
  public Http2Settings setMaxFrameSize(int maxFrameSize) {
    Arguments.require(maxFrameSize >= Http2CodecUtil.MAX_FRAME_SIZE_LOWER_BOUND,
        "maxFrameSize must be >= " + Http2CodecUtil.MAX_FRAME_SIZE_LOWER_BOUND);
    Arguments.require(maxFrameSize <= Http2CodecUtil.MAX_FRAME_SIZE_UPPER_BOUND,
        "maxFrameSize must be <= " + Http2CodecUtil.MAX_FRAME_SIZE_UPPER_BOUND);
    this.maxFrameSize = maxFrameSize;
    return this;
  }

  
Returns:
the SETTINGS_MAX_HEADER_LIST_SIZE HTTP/2 setting/**
   * @return the {@literal SETTINGS_MAX_HEADER_LIST_SIZE} HTTP/2 setting
   */
  public long getMaxHeaderListSize() {
    return maxHeaderListSize;
  }

  
Set the SETTINGS_MAX_HEADER_LIST_SIZE HTTP/2 setting 
Params:
maxHeaderListSize – the new value
Returns:
a reference to this, so the API can be used fluently/**
   * Set the {@literal SETTINGS_MAX_HEADER_LIST_SIZE} HTTP/2 setting
   *
   * @param maxHeaderListSize the new value
   * @return a reference to this, so the API can be used fluently
   */
  public Http2Settings setMaxHeaderListSize(long maxHeaderListSize) {
    Arguments.require(maxHeaderListSize >= 0, "maxHeaderListSize must be >= 0");
    Arguments.require(maxHeaderListSize >= Http2CodecUtil.MIN_HEADER_LIST_SIZE,
        "maxHeaderListSize must be >= " + Http2CodecUtil.MIN_HEADER_LIST_SIZE);
    this.maxHeaderListSize = maxHeaderListSize;
    return this;
  }

  
Returns:
the extra settings used for extending HTTP/2/**
   * @return the extra settings used for extending HTTP/2
   */
  @GenIgnore
  public Map<Integer, Long> getExtraSettings() {
    return extraSettings;
  }

  
Set the extra setting used for extending HTTP/2
Params:
settings – the new extra settings
Returns:
a reference to this, so the API can be used fluently/**
   * Set the extra setting used for extending HTTP/2
   *
   * @param settings the new extra settings
   * @return a reference to this, so the API can be used fluently
   */
  @GenIgnore
  public Http2Settings setExtraSettings(Map<Integer, Long> settings) {
    extraSettings = settings;
    return this;
  }

  
Return a setting value according to its identifier.
Params:
id – the setting identifier
Returns:
the setting value/**
   * Return a setting value according to its identifier.
   *
   * @param id the setting identifier
   * @return the setting value
   */
  public Long get(int id) {
    switch (id) {
      case 1:
        return headerTableSize;
      case 2:
        return pushEnabled ? 1L : 0L;
      case 3:
        return maxConcurrentStreams;
      case 4:
        return (long)initialWindowSize;
      case 5:
        return (long)maxFrameSize;
      case 6:
        return (long)maxHeaderListSize;
      default:
        return extraSettings != null ? extraSettings.get(id) : null;
    }
  }

  
Set a setting value for a given setting id. 
Params:
id – the setting id
value – the setting value
Returns:
a reference to this, so the API can be used fluently/**
   * Set a setting {@code value} for a given setting {@code id}.
   *
   * @param id the setting id
   * @param value the setting value
   * @return a reference to this, so the API can be used fluently
   */
  public Http2Settings set(int id, long value) {
    Arguments.require(id >= 0 && id <= 0xFFFF, "Setting id must me an unsigned 16-bit value");
    Arguments.require(value >= 0L && value <= 0xFFFFFFFFL, "Setting value must me an unsigned 32-bit value");
    switch (id) {
      case 1:
        setHeaderTableSize(value);
        break;
      case 2:
        Arguments.require(value == 0 || value == 1, "enablePush must be 0 or 1");
        setPushEnabled(value == 1);
        break;
      case 3:
        setMaxConcurrentStreams(value);
        break;
      case 4:
        setInitialWindowSize((int) value);
        break;
      case 5:
        setMaxFrameSize((int) value);
        break;
      case 6:
        Arguments.require(value <= Integer.MAX_VALUE, "maxHeaderListSize must be <= " + Integer.MAX_VALUE);
        setMaxHeaderListSize((int) value);
        break;
      default:
        if (extraSettings == null) {
          extraSettings = new HashMap<>();
        }
        extraSettings.put(id, value);
    }
    return this;
  }

  @Override
  public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;

    Http2Settings that = (Http2Settings) o;

    if (headerTableSize != that.headerTableSize) return false;
    if (pushEnabled != that.pushEnabled) return false;
    if (maxConcurrentStreams != that.maxConcurrentStreams) return false;
    if (initialWindowSize != that.initialWindowSize) return false;
    if (maxFrameSize != that.maxFrameSize) return false;
    if (maxHeaderListSize != that.maxHeaderListSize) return false;
    return true;
  }

  @Override
  public int hashCode() {
    int result = (int) (headerTableSize ^ (headerTableSize >>> 32));
    result = 31 * result + (pushEnabled ? 1 : 0);
    result = 31 * result + (int) (maxConcurrentStreams ^ (maxConcurrentStreams >>> 32));
    result = 31 * result + initialWindowSize;
    result = 31 * result + maxFrameSize;
    result = 31 * result + (int) (maxHeaderListSize ^ (maxHeaderListSize >>> 32));
    return result;
  }

  @Override
  public String toString() {
    return toJson().encode();
  }

  public JsonObject toJson() {
    JsonObject json = new JsonObject();
    Http2SettingsConverter.toJson(this, json);
    return json;
  }
}