using System;
using System.Linq;
using System.Collections.Generic;
using System.Globalization;
using HeuristicLab.Algorithms.Bandits;
using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace HeuristicLab.Problems.GrammaticalOptimization.Test {
  [TestClass]
  public class TestSequence {

    [TestMethod]
    public void TestCtorAndProperties() {
      CultureInfo.DefaultThreadCurrentCulture = CultureInfo.InvariantCulture;
      {
        var s = new Sequence("A");
        Assert.AreEqual(1, s.Length);
        Assert.AreEqual(false, s.IsTerminal);
        Assert.AreEqual(0, s.FirstNonTerminalIndex);
        Assert.AreEqual('A', s.FirstNonTerminal);
      }
      {
        var s = new Sequence("AB");
        Assert.AreEqual(2, s.Length);
        Assert.AreEqual(false, s.IsTerminal);
        Assert.AreEqual(0, s.FirstNonTerminalIndex);
        Assert.AreEqual('A', s.FirstNonTerminal);
      }
      {
        var s = new Sequence("aAB");
        Assert.AreEqual(3, s.Length);
        Assert.AreEqual(false, s.IsTerminal);
        Assert.AreEqual(1, s.FirstNonTerminalIndex);
        Assert.AreEqual('A', s.FirstNonTerminal);
      }
      {
        var s = new Sequence("aaaaA");
        Assert.AreEqual(5, s.Length);
        Assert.AreEqual(false, s.IsTerminal);
        Assert.AreEqual(4, s.FirstNonTerminalIndex);
        Assert.AreEqual('A', s.FirstNonTerminal);
      }
      {
        var s = new Sequence("aaaa");
        Assert.AreEqual(4, s.Length);
        Assert.AreEqual(true, s.IsTerminal);
        Assert.AreEqual(-1, s.FirstNonTerminalIndex);
        try {
          var nt = s.FirstNonTerminal;
          Assert.Fail();
        } catch (IndexOutOfRangeException e) {
        }
      }
      {
        var s = new Sequence("aaaaA");
        var t = new Sequence(s);
        Assert.AreEqual(5, t.Length);
        Assert.AreEqual(false, t.IsTerminal);
        Assert.AreEqual(4, t.FirstNonTerminalIndex);
        Assert.AreEqual('A', t.FirstNonTerminal);

        t.ReplaceAt(0, 1, new Sequence("Z"));
        Assert.AreEqual(5, t.Length);
        Assert.AreEqual(false, t.IsTerminal);
        Assert.AreEqual(0, t.FirstNonTerminalIndex);
        Assert.AreEqual('Z', t.FirstNonTerminal);

        // s must not be changed
        Assert.AreEqual(5, s.Length);
        Assert.AreEqual(false, s.IsTerminal);
        Assert.AreEqual(4, s.FirstNonTerminalIndex);
        Assert.AreEqual('A', s.FirstNonTerminal);
      }
    }

    [TestMethod]
    public void TestReplaceAt() {
      CultureInfo.DefaultThreadCurrentCulture = CultureInfo.InvariantCulture;
      {
        var s = new Sequence("A");
        var t = new Sequence("B");

        s.ReplaceAt(0, 1, t);
        Assert.AreEqual('B', s.FirstNonTerminal);
        Assert.AreEqual(1, s.Length);
      }
      {
        var s = new Sequence("A");
        var t = new Sequence("b");

        s.ReplaceAt(0, 1, t);
        Assert.AreEqual(-1, s.FirstNonTerminalIndex);
        Assert.AreEqual(1, s.Length);
      }
      {
        var s = new Sequence("a");
        var t = new Sequence("B");

        s.ReplaceAt(0, 1, t);
        Assert.AreEqual('B', s.FirstNonTerminal);
        Assert.AreEqual(1, s.Length);
      }
      {
        var s = new Sequence("AB");
        var t = new Sequence("a");

        s.ReplaceAt(0, 1, t);
        Assert.AreEqual(1, s.FirstNonTerminalIndex);
        Assert.AreEqual('B', s.FirstNonTerminal);
        Assert.AreEqual(2, s.Length);
      }
      {
        var s = new Sequence("AB");
        var t = new Sequence("aa");

        s.ReplaceAt(0, 1, t);
        Assert.AreEqual(2, s.FirstNonTerminalIndex);
        Assert.AreEqual('B', s.FirstNonTerminal);
        Assert.AreEqual(3, s.Length);
        Assert.AreEqual("aaB", s.ToString());
      }
      {
        var s = new Sequence("AB");
        var t = new Sequence("bb");

        s.ReplaceAt(1, 1, t);
        Assert.AreEqual(0, s.FirstNonTerminalIndex);
        Assert.AreEqual('A', s.FirstNonTerminal);
        Assert.AreEqual(3, s.Length);
        Assert.AreEqual("Abb", s.ToString());
      }
      {
        var s = new Sequence("AB");
        var t = new Sequence("aA");

        s.ReplaceAt(0, 1, t);
        Assert.AreEqual(1, s.FirstNonTerminalIndex);
        Assert.AreEqual('A', s.FirstNonTerminal);
        Assert.AreEqual(3, s.Length);
        Assert.AreEqual("aAB", s.ToString());
      }
      {
        var s = new Sequence("AaaB");
        var t = new Sequence("a");

        s.ReplaceAt(0, 3, t);
        Assert.AreEqual(1, s.FirstNonTerminalIndex);
        Assert.AreEqual('B', s.FirstNonTerminal);
        Assert.AreEqual(2, s.Length);
        Assert.AreEqual("aB", s.ToString());
      }
      {
        var s = new Sequence("AaaB");
        var t = new Sequence("aAa");

        s.ReplaceAt(0, 3, t);
        Assert.AreEqual(1, s.FirstNonTerminalIndex);
        Assert.AreEqual('A', s.FirstNonTerminal);
        Assert.AreEqual("aAaB", s.ToString());
      }
      {
        var s = new Sequence("aaaA");
        var t = new Sequence("aaa");

        s.ReplaceAt(3, 1, t);
        Assert.AreEqual(-1, s.FirstNonTerminalIndex);
        Assert.AreEqual("aaaaaa", s.ToString());
      }
      {
        var s = new Sequence("aaaA");
        var t = new Sequence("aaa");

        s.ReplaceAt(1, 3, t);
        Assert.AreEqual(-1, s.FirstNonTerminalIndex);
        Assert.AreEqual("aaaa", s.ToString());
      }
      {
        var s = new Sequence("aaaA");
        var t = new Sequence("aaa");

        s.ReplaceAt(0, 4, t);
        Assert.AreEqual(-1, s.FirstNonTerminalIndex);
        Assert.AreEqual("aaa", s.ToString());
      }
      {
        var s = new Sequence("aaaA");
        var t = new Sequence("aAaAA");

        s.ReplaceAt(0, 4, t);
        Assert.AreEqual(1, s.FirstNonTerminalIndex);
        Assert.AreEqual("aAaAA", s.ToString());
      }

      // testing length checks
      {
        var s = new Sequence("aA");
        var t = new Sequence("aA");

        try {
          s.ReplaceAt(0, 4, t);
          Assert.Fail();
        } catch (ArgumentException) { }

        s.ReplaceAt(0, 2, t); // should work

        try {
          s.ReplaceAt(0, 3, t);
          Assert.Fail();
        } catch (ArgumentException) { }

        try {
          s.ReplaceAt(1, 2, t);
          Assert.Fail();
        } catch (ArgumentException) { }

        s.ReplaceAt(1, 1, new Sequence("A")); // should work

        try {
          s.ReplaceAt(-1, 2, t);
          Assert.Fail();
        } catch (ArgumentException) { }

      }
    }

    [TestMethod]
    public void TestSubsequence() {
      CultureInfo.DefaultThreadCurrentCulture = CultureInfo.InvariantCulture;
      {
        var s = new Sequence("AAaaaAA");
        var sub = s.Subsequence(0, 7);

        Assert.AreEqual(0, sub.FirstNonTerminalIndex);
        Assert.AreEqual("AAaaaAA", sub.ToString());
      }
      {
        var s = new Sequence("AAaaaAA");
        var sub = s.Subsequence(0, 3);

        Assert.AreEqual(0, sub.FirstNonTerminalIndex);
        Assert.AreEqual("AAa", sub.ToString());
      }
      {
        var s = new Sequence("AAaaaAA");
        var sub = s.Subsequence(2, 3);

        Assert.AreEqual(-1, sub.FirstNonTerminalIndex);
        Assert.AreEqual("aaa", sub.ToString());
      }
      {
        var s = new Sequence("AAaaaAA");
        var sub = s.Subsequence(2, 4);

        Assert.AreEqual(3, sub.FirstNonTerminalIndex);
        Assert.AreEqual("aaaA", sub.ToString());
      }
      {
        var s = new Sequence("AAaaaAA");
        var sub = s.Subsequence(5, 2);

        Assert.AreEqual(0, sub.FirstNonTerminalIndex);
        Assert.AreEqual("AA", sub.ToString());
      }
      {
        var s = new Sequence("aaaAA");
        var sub = s.Subsequence(2, 3);

        Assert.AreEqual(1, sub.FirstNonTerminalIndex);
        Assert.AreEqual("aAA", sub.ToString());
      }
    }

    [TestMethod]
    public void TestReadonlySequence() {
      CultureInfo.DefaultThreadCurrentCulture = CultureInfo.InvariantCulture;
      {
        var s = new ReadonlySequence("AAaaaAA");
        var sub = s.Subsequence(0, 7);

        Assert.AreEqual(0, sub.FirstNonTerminalIndex);
        Assert.AreEqual("AAaaaAA", sub.ToString());
      }
      {
        var s = new ReadonlySequence("AAaaaAA");
        var sub = s.Subsequence(0, 3);

        Assert.AreEqual(0, sub.FirstNonTerminalIndex);
        Assert.AreEqual("AAa", sub.ToString());

        sub = sub.Subsequence(1, 2);
        Assert.AreEqual(0, sub.FirstNonTerminalIndex);
        Assert.AreEqual("Aa", sub.ToString());
      }
      {
        var s = new ReadonlySequence("AAaaaAA");
        var sub = s.Subsequence(2, 3);

        Assert.AreEqual(-1, sub.FirstNonTerminalIndex);
        Assert.AreEqual("aaa", sub.ToString());
      }
      {
        var s = new ReadonlySequence("AAaaaAA");
        var sub = s.Subsequence(2, 4);

        Assert.AreEqual(3, sub.FirstNonTerminalIndex);
        Assert.AreEqual("aaaA", sub.ToString());
      }
      {
        var s = new ReadonlySequence("AAaaaAA");
        var sub = s.Subsequence(5, 2);

        Assert.AreEqual(0, sub.FirstNonTerminalIndex);
        Assert.AreEqual("AA", sub.ToString());
      }
      {
        var s = new ReadonlySequence("aaaAA");
        var sub = s.Subsequence(2, 3);

        Assert.AreEqual(1, sub.FirstNonTerminalIndex);
        Assert.AreEqual("aAA", sub.ToString());
      }

    }
  }
}