/*
 * Copyright 2018, OpenCensus Authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package io.opencensus.trace;

import static com.google.common.truth.Truth.assertThat;

import com.google.common.testing.EqualsTester;
import io.opencensus.trace.Tracestate.Entry;
import java.util.Arrays;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;

/** Unit tests for {@link Tracestate}. */
@RunWith(JUnit4.class)
public class TracestateTest {
  private static final String FIRST_KEY = "key_1";
  private static final String SECOND_KEY = "key_2";
  private static final String FIRST_VALUE = "value.1";
  private static final String SECOND_VALUE = "value.2";

  @Rule public final ExpectedException thrown = ExpectedException.none();

  private static final Tracestate EMPTY = Tracestate.builder().build();
  private final Tracestate firstTracestate = EMPTY.toBuilder().set(FIRST_KEY, FIRST_VALUE).build();
  private final Tracestate secondTracestate =
      EMPTY.toBuilder().set(SECOND_KEY, SECOND_VALUE).build();
  private final Tracestate multiValueTracestate =
      EMPTY.toBuilder().set(FIRST_KEY, FIRST_VALUE).set(SECOND_KEY, SECOND_VALUE).build();

  @Test
  public void get() {
    assertThat(firstTracestate.get(FIRST_KEY)).isEqualTo(FIRST_VALUE);
    assertThat(secondTracestate.get(SECOND_KEY)).isEqualTo(SECOND_VALUE);
    assertThat(multiValueTracestate.get(FIRST_KEY)).isEqualTo(FIRST_VALUE);
    assertThat(multiValueTracestate.get(SECOND_KEY)).isEqualTo(SECOND_VALUE);
  }

  @Test
  public void getEntries() {
    assertThat(firstTracestate.getEntries()).containsExactly(Entry.create(FIRST_KEY, FIRST_VALUE));
    assertThat(secondTracestate.getEntries())
        .containsExactly(Entry.create(SECOND_KEY, SECOND_VALUE));
    assertThat(multiValueTracestate.getEntries())
        .containsExactly(
            Entry.create(FIRST_KEY, FIRST_VALUE), Entry.create(SECOND_KEY, SECOND_VALUE));
  }

  @Test
  public void disallowsNullKey() {
    thrown.expect(NullPointerException.class);
    EMPTY.toBuilder().set(null, FIRST_VALUE).build();
  }

  @Test
  public void invalidFirstKeyCharacter() {
    thrown.expect(IllegalArgumentException.class);
    EMPTY.toBuilder().set("1_key", FIRST_VALUE).build();
  }

  @Test
  public void invalidKeyCharacters() {
    thrown.expect(IllegalArgumentException.class);
    EMPTY.toBuilder().set("kEy_1", FIRST_VALUE).build();
  }

  @Test
  public void invalidKeySize() {
    char[] chars = new char[257];
    Arrays.fill(chars, 'a');
    String longKey = new String(chars);
    thrown.expect(IllegalArgumentException.class);
    EMPTY.toBuilder().set(longKey, FIRST_VALUE).build();
  }

  @Test
  public void allAllowedKeyCharacters() {
    StringBuilder stringBuilder = new StringBuilder();
    for (char c = 'a'; c <= 'z'; c++) {
      stringBuilder.append(c);
    }
    for (char c = '0'; c <= '9'; c++) {
      stringBuilder.append(c);
    }
    stringBuilder.append('_');
    stringBuilder.append('-');
    stringBuilder.append('*');
    stringBuilder.append('/');
    String allowedKey = stringBuilder.toString();
    assertThat(EMPTY.toBuilder().set(allowedKey, FIRST_VALUE).build().get(allowedKey))
        .isEqualTo(FIRST_VALUE);
  }

  @Test
  public void disallowsNullValue() {
    thrown.expect(NullPointerException.class);
    EMPTY.toBuilder().set(FIRST_KEY, null).build();
  }

  @Test
  public void valueCannotContainEqual() {
    thrown.expect(IllegalArgumentException.class);
    EMPTY.toBuilder().set(FIRST_KEY, "my_vakue=5").build();
  }

  @Test
  public void valueCannotContainComma() {
    thrown.expect(IllegalArgumentException.class);
    EMPTY.toBuilder().set(FIRST_KEY, "first,second").build();
  }

  @Test
  public void valueCannotContainTrailingSpaces() {
    thrown.expect(IllegalArgumentException.class);
    EMPTY.toBuilder().set(FIRST_KEY, "first ").build();
  }

  @Test
  public void invalidValueSize() {
    char[] chars = new char[257];
    Arrays.fill(chars, 'a');
    String longValue = new String(chars);
    thrown.expect(IllegalArgumentException.class);
    EMPTY.toBuilder().set(FIRST_KEY, longValue).build();
  }

  @Test
  public void allAllowedValueCharacters() {
    StringBuilder stringBuilder = new StringBuilder();
    for (char c = ' ' /* '\u0020' */; c <= '~' /* '\u007E' */; c++) {
      if (c == ',' || c == '=') {
        continue;
      }
      stringBuilder.append(c);
    }
    String allowedValue = stringBuilder.toString();
    assertThat(EMPTY.toBuilder().set(FIRST_KEY, allowedValue).build().get(FIRST_KEY))
        .isEqualTo(allowedValue);
  }

  @Test
  public void addEntry() {
    assertThat(firstTracestate.toBuilder().set(SECOND_KEY, SECOND_VALUE).build())
        .isEqualTo(multiValueTracestate);
  }

  @Test
  public void updateEntry() {
    assertThat(firstTracestate.toBuilder().set(FIRST_KEY, SECOND_VALUE).build().get(FIRST_KEY))
        .isEqualTo(SECOND_VALUE);
    Tracestate updatedMultiValueTracestate =
        multiValueTracestate.toBuilder().set(FIRST_KEY, SECOND_VALUE).build();
    assertThat(updatedMultiValueTracestate.get(FIRST_KEY)).isEqualTo(SECOND_VALUE);
    assertThat(updatedMultiValueTracestate.get(SECOND_KEY)).isEqualTo(SECOND_VALUE);
  }

  @Test
  public void addAndUpdateEntry() {
    assertThat(
            firstTracestate
                .toBuilder()
                .set(FIRST_KEY, SECOND_VALUE) // update the existing entry
                .set(SECOND_KEY, FIRST_VALUE) // add a new entry
                .build()
                .getEntries())
        .containsExactly(
            Entry.create(FIRST_KEY, SECOND_VALUE), Entry.create(SECOND_KEY, FIRST_VALUE));
  }

  @Test
  public void addSameKey() {
    assertThat(
            EMPTY
                .toBuilder()
                .set(FIRST_KEY, SECOND_VALUE) // update the existing entry
                .set(FIRST_KEY, FIRST_VALUE) // add a new entry
                .build()
                .getEntries())
        .containsExactly(Entry.create(FIRST_KEY, FIRST_VALUE));
  }

  @Test
  public void remove() {
    assertThat(multiValueTracestate.toBuilder().remove(SECOND_KEY).build())
        .isEqualTo(firstTracestate);
  }

  @Test
  public void addAndRemoveEntry() {
    assertThat(
            EMPTY
                .toBuilder()
                .set(FIRST_KEY, SECOND_VALUE) // update the existing entry
                .remove(FIRST_KEY) // add a new entry
                .build())
        .isEqualTo(EMPTY);
  }

  @Test
  public void remove_NullNotAllowed() {
    thrown.expect(NullPointerException.class);
    multiValueTracestate.toBuilder().remove(null).build();
  }

  @Test
  public void tracestate_EqualsAndHashCode() {
    EqualsTester tester = new EqualsTester();
    tester.addEqualityGroup(EMPTY, EMPTY);
    tester.addEqualityGroup(firstTracestate, EMPTY.toBuilder().set(FIRST_KEY, FIRST_VALUE).build());
    tester.addEqualityGroup(
        secondTracestate, EMPTY.toBuilder().set(SECOND_KEY, SECOND_VALUE).build());
    tester.testEquals();
  }

  @Test
  public void tracestate_ToString() {
    assertThat(EMPTY.toString()).isEqualTo("Tracestate{entries=[]}");
  }
}