/*
 *
 *  Licensed to the Apache Software Foundation (ASF) under one
 *  or more contributor license agreements.  See the NOTICE file
 *  distributed with this work for additional information
 *  regarding copyright ownership.  The ASF licenses this file
 *  to you 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 org.apache.metron.stellar.common.utils;

import com.google.common.collect.ImmutableList;
import org.junit.jupiter.api.Test;

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

import static org.junit.jupiter.api.Assertions.*;

/**
 * Tests the Serializer.
 */
public class SerDeUtilsTest {

  @Test
  public void testInteger() {
    final int expected = 2;
    byte[] raw = SerDeUtils.toBytes(expected);
    int actual = SerDeUtils.fromBytes(raw, Integer.class);
    assertEquals(expected, actual);
  }

  @Test
  public void testDouble() {
    final double expected = 2.0;
    byte[] raw = SerDeUtils.toBytes(expected);
    {
      double actual = SerDeUtils.fromBytes(raw, Double.class);
      assertEquals(expected, actual, 0.01);
    }
    {
      double actual = (double) SerDeUtils.fromBytes(raw, Object.class);
      assertEquals(expected, actual, 0.01);
    }
  }

  @Test
  public void testShort() {
    final short expected = 2;
    byte[] raw = SerDeUtils.toBytes(expected);
    {
      short actual = SerDeUtils.fromBytes(raw, Short.class);
      assertEquals(expected, actual);
    }
    {
      short actual = (short) SerDeUtils.fromBytes(raw, Object.class);
      assertEquals(expected, actual);
    }
  }

  @Test
  public void testLong() {
    final long expected = 2L;
    byte[] raw = SerDeUtils.toBytes(expected);
    {
      long actual = SerDeUtils.fromBytes(raw, Long.class);
      assertEquals(expected, actual);
    }
    {
      long actual = (Long) SerDeUtils.fromBytes(raw, Object.class);
      assertEquals(expected, actual);
    }
  }

  @Test
  public void testFloat() {
    final Float expected = 2.2F;
    byte[] raw = SerDeUtils.toBytes(expected);
    {
      float actual = SerDeUtils.fromBytes(raw, Float.class);
      assertEquals(expected, actual, 0.01);
    }
    {
      float actual = (float) SerDeUtils.fromBytes(raw, Object.class);
      assertEquals(expected, actual, 0.01);
    }
  }

  @Test
  public void testMap() {
    final Map<String, Object> expected = new HashMap<>();
    expected.put("foo", "bar");
    expected.put( "bar", 1.0);
    ;
    byte[] raw = SerDeUtils.toBytes(expected);
    Object actual = SerDeUtils.fromBytes(raw, Object.class);
    assertEquals(expected, actual);
  }

  @Test
  public void testList() {
    final List<String> expected = new ArrayList<String>();
    expected.add("foo");
    expected.add("bar");
    byte[] raw = SerDeUtils.toBytes(expected);
    Object actual = SerDeUtils.fromBytes(raw, Object.class);
    assertEquals(expected, actual);
  }

  @Test
  @SuppressWarnings("unchecked")
  public void testBloomFilter() {
    final BloomFilter<Object> expected = new BloomFilter<>(new BloomFilter.DefaultSerializer<>(), 10000, 0.01);
    expected.add("foo");
    expected.add("bar");
    byte[] raw = SerDeUtils.toBytes(expected);
    BloomFilter<Object> actual = (BloomFilter) SerDeUtils.fromBytes(raw, Object.class);
    assertTrue(actual.mightContain("foo"));
    assertFalse(actual.mightContain("timothy"));
    assertEquals(expected, actual);
  }

  public static class ArbitraryPojo {
    private List<String> list = new ArrayList<>();
    private String string = "foo";
    private Double d = 1.0;
    private Map<String, String> map = new HashMap<>();
    private List<String> immutableList = ImmutableList.of("foo");

    public ArbitraryPojo() {
      list.add("foo");
      list.add("bar");
      map.put("key1", "value1");
      map.put("key2", "value2");

    }

    public List<String> getList() {
      return list;
    }

    public void setList(List<String> list) {
      this.list = list;
    }

    public String getString() {
      return string;
    }

    public void setString(String string) {
      this.string = string;
    }

    public Double getD() {
      return d;
    }

    public void setD(Double d) {
      this.d = d;
    }

    public Map<String, String> getMap() {
      return map;
    }

    public void setMap(Map<String, String> map) {
      this.map = map;
    }

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

      ArbitraryPojo that = (ArbitraryPojo) o;

      if (getList() != null ? !getList().equals(that.getList()) : that.getList() != null) return false;
      if (getString() != null ? !getString().equals(that.getString()) : that.getString() != null) return false;
      if (getD() != null ? !getD().equals(that.getD()) : that.getD() != null) return false;
      if (getMap() != null ? !getMap().equals(that.getMap()) : that.getMap() != null) return false;
      return immutableList != null ? immutableList.equals(that.immutableList) : that.immutableList == null;

    }

    @Override
    public int hashCode() {
      int result = getList() != null ? getList().hashCode() : 0;
      result = 31 * result + (getString() != null ? getString().hashCode() : 0);
      result = 31 * result + (getD() != null ? getD().hashCode() : 0);
      result = 31 * result + (getMap() != null ? getMap().hashCode() : 0);
      result = 31 * result + (immutableList != null ? immutableList.hashCode() : 0);
      return result;
    }
  }

  @Test
  public void testArbitraryPojo() {
    final ArbitraryPojo expected = new ArbitraryPojo();
    byte[] raw = SerDeUtils.toBytes(expected);
    Object actual = SerDeUtils.fromBytes(raw, Object.class);
    assertEquals(expected, actual);
  }
}