package at.gv.egiz.eaaf.core.test.utils;

import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.jupiter.api.Assertions.assertThrows;

import java.io.Serializable;
import java.util.Collections;

import org.apache.commons.lang3.RandomStringUtils;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.BlockJUnit4ClassRunner;

import com.google.common.collect.Sets;

import at.gv.egiz.eaaf.core.exceptions.EaafAuthenticationException;
import at.gv.egiz.eaaf.core.exceptions.EaafException;
import at.gv.egiz.eaaf.core.impl.utils.EaafSerializationUtils;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.RequiredArgsConstructor;
import lombok.Setter;

@RunWith(BlockJUnit4ClassRunner.class)
public class EaafSerializationUtilsTest {

  @Test
  public void nullInput() {
    assertNull(EaafSerializationUtils.serialize(null));
    assertNull(EaafSerializationUtils.strictDeserialize(null, Sets.newHashSet(Throwable.class)));
    assertNull(EaafSerializationUtils.typeSpecificDeserialize(null,
        Sets.newHashSet(Throwable.class), String.class));

  }

  @Test
  public void strictMode() {
    DummyClassA dummyA = new DummyClassA(rand());
    dummyA.setMemberB(new DummyClassB(rand()));

    byte[] object = EaafSerializationUtils.serialize(dummyA);

    assertThrows(IllegalArgumentException.class, () -> EaafSerializationUtils.strictDeserialize(
        object, Sets.newHashSet(Throwable.class)));
    assertThrows(IllegalArgumentException.class, () -> EaafSerializationUtils.strictDeserialize(
        object, Sets.newHashSet(DummyClassA.class)));

    assertNotNull(EaafSerializationUtils.strictDeserialize(object, Sets.newHashSet(
        DummyClassA.class, DummyClassB.class)));

  }

  @Test
  public void typeModeSimple() {
    DummyClassC dummyC = new DummyClassC(rand());

    byte[] object = EaafSerializationUtils.serialize(dummyC);

    assertThrows(IllegalArgumentException.class, () -> EaafSerializationUtils.typeSpecificDeserialize(
        object, Sets.newHashSet(DummyClassA.class), String.class));
    assertThrows(IllegalArgumentException.class, () -> EaafSerializationUtils.typeSpecificDeserialize(
        object, Sets.newHashSet(DummyClassB.class), DummyClassC.class));
    assertThrows(IllegalArgumentException.class, () -> EaafSerializationUtils.typeSpecificDeserialize(
        object, Sets.newHashSet(DummyClassC.class), DummyClassA.class));

    assertNotNull(EaafSerializationUtils.typeSpecificDeserialize(
        object, Sets.newHashSet(DummyClassA.class), DummyClassC.class));
    assertNotNull(EaafSerializationUtils.typeSpecificDeserialize(
        object, Sets.newHashSet(DummyClassA.class), DummyClassA.class));

  }

  @Test
  public void typeModeComplex() {

    DummyClassC dummyC = new DummyClassC(rand());
    dummyC.setMemberB(new DummyClassB(rand()));

    byte[] object = EaafSerializationUtils.serialize(dummyC);

    // missing DummyClassB
    assertThrows(IllegalArgumentException.class, () -> EaafSerializationUtils.typeSpecificDeserialize(
        object, Sets.newHashSet(DummyClassA.class), DummyClassC.class));

    assertThrows(IllegalArgumentException.class, () -> EaafSerializationUtils.typeSpecificDeserialize(
        object, Sets.newHashSet(DummyClassC.class, DummyClassB.class), DummyClassC.class));

    assertThrows(IllegalArgumentException.class, () -> EaafSerializationUtils.typeSpecificDeserialize(
        object, Sets.newHashSet(DummyClassB.class, DummyClassA.class), DummyClassB.class));

    assertNotNull(EaafSerializationUtils.typeSpecificDeserialize(
        object, Sets.newHashSet(DummyClassA.class, DummyClassB.class), DummyClassA.class));
    assertNotNull(EaafSerializationUtils.typeSpecificDeserialize(
        object, Sets.newHashSet(DummyClassA.class, DummyClassB.class), DummyClassC.class));

  }

  @Test
  public void typeModeComplexWithObject() {

    DummyClassC dummyC = new DummyClassC(rand());
    DummyClassD dummyD = new DummyClassD(rand());
    dummyC.setMemberB(dummyD);
    dummyD.setAnyType(new EaafException(rand()));

    byte[] object = EaafSerializationUtils.serialize(dummyC);

    assertThrows(IllegalArgumentException.class, () -> EaafSerializationUtils.typeSpecificDeserialize(
        object, Sets.newHashSet(DummyClassA.class, DummyClassB.class), DummyClassA.class));

    assertThrows(IllegalArgumentException.class, () -> EaafSerializationUtils.typeSpecificDeserialize(
        object, Sets.newHashSet(DummyClassA.class, DummyClassB.class), DummyClassC.class));

    assertThrows(IllegalArgumentException.class, () -> EaafSerializationUtils.typeSpecificDeserialize(
        object, Sets.newHashSet(DummyClassA.class, DummyClassB.class), DummyClassC.class));

    assertNotNull(EaafSerializationUtils.typeSpecificDeserialize(
        object, Sets.newHashSet(DummyClassA.class, DummyClassB.class,
            Throwable.class, StackTraceElement[].class,
            StackTraceElement.class, Collections.EMPTY_LIST.getClass()), DummyClassA.class));

  }

  @Test
  public void typeModeComplexNullObject() {

    DummyClassC dummyC = new DummyClassC(rand());
    DummyClassD dummyD = new DummyClassD(rand());
    dummyC.setMemberB(dummyD);

    byte[] object = EaafSerializationUtils.serialize(dummyC);

    assertNotNull(EaafSerializationUtils.typeSpecificDeserialize(
        object, Sets.newHashSet(DummyClassA.class, DummyClassB.class), DummyClassA.class));

  }

  @Test
  public void typeModeWithExceptions() {
    EaafException error1 = new EaafException(rand());
    EaafAuthenticationException error2 = new EaafAuthenticationException(rand(), null, error1);

    byte[] object = EaafSerializationUtils.serialize(error2);

    // check if less allowed classes throw a deserialization exception
    assertThrows(IllegalArgumentException.class, () -> EaafSerializationUtils.typeSpecificDeserialize(
        object, Sets.newHashSet(Throwable.class), Throwable.class));
    assertThrows(IllegalArgumentException.class, () -> EaafSerializationUtils.typeSpecificDeserialize(
        object, Sets.newHashSet(Throwable.class, StackTraceElement[].class, StackTraceElement.class),
        Throwable.class));

    // minimum allowed classes to de-serialize an Throwable
    assertNotNull(EaafSerializationUtils.typeSpecificDeserialize(
        object, Sets.newHashSet(Throwable.class, StackTraceElement[].class,
            StackTraceElement.class, Collections.EMPTY_LIST.getClass()),
        Throwable.class));

  }

  @Test
  public void typeModeWithExceptionsAndParams() {
    EaafException error1 = new EaafException(rand());
    EaafAuthenticationException error2 = new EaafAuthenticationException(rand(),
        new Object[] {
            Integer.valueOf(17),
            String.valueOf(17.1),
            Float.valueOf("18.3")
        },
        error1);

    byte[] object = EaafSerializationUtils.serialize(error2);

    // check if less allowed classes throw a deserialization exception
    assertThrows(IllegalArgumentException.class, () -> EaafSerializationUtils.typeSpecificDeserialize(
        object, Sets.newHashSet(Throwable.class), Throwable.class));
    assertThrows(IllegalArgumentException.class, () -> EaafSerializationUtils.typeSpecificDeserialize(
        object, Sets.newHashSet(Throwable.class, StackTraceElement[].class, StackTraceElement.class),
        Throwable.class));

    // minimum allowed classes to de-serialize an Throwable
    assertNotNull(EaafSerializationUtils.typeSpecificDeserialize(
        object, Sets.newHashSet(Throwable.class, StackTraceElement[].class,
            StackTraceElement.class, Collections.EMPTY_LIST.getClass(),
            Integer.class, Long.class, Double.class, Float.class, String.class, Number.class),
        Throwable.class));

  }

  private String rand() {
    return RandomStringUtils.randomAlphanumeric(10);
  }

  @Getter
  @RequiredArgsConstructor
  public static class DummyClassA implements Serializable {

    private static final long serialVersionUID = 1L;

    private final String test;

    @Setter
    private DummyClassB memberB;

  }

  @Getter
  @AllArgsConstructor
  public static class DummyClassB implements Serializable {

    private static final long serialVersionUID = 1L;

    private final String test;

  }

  @Getter
  public static class DummyClassD extends DummyClassB implements Serializable {

    private static final long serialVersionUID = 1L;

    public DummyClassD(String data) {
      super(data);
    }

    @Setter
    private Object anyType;

  }

  @Getter
  public static class DummyClassC extends DummyClassA implements Serializable {

    private static final long serialVersionUID = 1L;

    public DummyClassC(String data) {
      super(data);

      this.test = data;
    }

    private final String test;

  }

}