// Copyright 2017 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

import 'package:flutter_test/flutter_test.dart';
import 'package:mondrian/models/tree/tree.dart';

/// Convenience function for making trees

Tree<String> t(Tree<String> node, {List<Tree<String>> children}) {
  children?.forEach(node.add);
  return node;
}

void main() {
  Tree<String> grandparent; // the root
  Tree<String> parent;
  Tree<String> uncle;
  Tree<String> aunt;
  Tree<String> cousin;
  Tree<String> sibling;
  Tree<String> sibling2;
  Tree<String> niece;
  Tree<String> child;

  Tree<String> trimmedTree;
  Forest<String> forest;

  Tree<String> secondRoot;
  Tree<String> friend;
  Tree<String> childFriend;

  List<Tree<String>> expectedTree;
  List<Tree<String>> expectedForest;

  setUp(() {
    grandparent = Tree<String>(value: 'grandparent');
    parent = Tree<String>(value: 'parent');
    uncle = Tree<String>(value: 'uncle');
    aunt = Tree<String>(value: 'aunt');
    cousin = Tree<String>(value: 'cousin');
    sibling = Tree<String>(value: 'sibling');
    sibling2 = Tree<String>(value: 'sibling2');
    niece = Tree<String>(value: 'niece');
    child = Tree<String>(value: 'child');

    grandparent = t(
      // the root
      grandparent,
      children: <Tree<String>>[
        t(
          parent,
          children: <Tree<String>>[
            sibling,
            child,
            t(
              sibling2,
              children: <Tree<String>>[niece],
            ),
          ],
        ),
        uncle,
        t(
          aunt,
          children: <Tree<String>>[cousin],
        ),
      ],
    );

    trimmedTree = t(
      Tree<String>(value: grandparent.value),
      children: <Tree<String>>[uncle, aunt],
    );

    forest = Forest<String>()..add(grandparent);

    secondRoot = Tree<String>(value: 'parent of friend');
    friend = Tree<String>(value: 'friend');
    childFriend = Tree<String>(value: 'child of friend');

    secondRoot = t(
      secondRoot, // the root
      children: <Tree<String>>[
        t(
          friend,
          children: <Tree<String>>[childFriend],
        ),
      ],
    );

    expectedTree = <Tree<String>>[
      grandparent,
      parent,
      uncle,
      aunt,
      sibling,
      child,
      sibling2,
      cousin,
      niece
    ];

    expectedForest = <Tree<String>>[
      grandparent,
      parent,
      uncle,
      aunt,
      sibling,
      child,
      sibling2,
      cousin,
      niece,
      secondRoot,
      friend,
      childFriend
    ];

    forest.add(secondRoot);
  });

  group('Test Tree in tree.dart', () {
    test('we can find root', () {
      expect(niece.root.value, equals(grandparent.value));
    });
    test('we can find correct children', () {
      print(grandparent.children);
      expect(grandparent.children, equals(<Tree<String>>[parent, uncle, aunt]));
    });
    test('we can find correct ancestors', () {
      expect(niece.ancestors,
          equals(<Tree<String>>[sibling2, parent, grandparent]));
    });
    test('we can find correct parent', () {
      expect(niece.parent, equals(sibling2));
    });
    test('flatten works as expected (breadth-first)', () {
      // flatten - breadth first
      expect(grandparent.flatten().toList(), equals(expectedTree));
    });
    test('we detach nodes correctly', () {
      parent.detach();
      expect(grandparent.values, equals(trimmedTree.values));
    });
    test('ancestors are correct post-detachement', () {
      parent.detach();
      expect(niece.ancestors, equals(<Tree<String>>[sibling2, parent]));
    });
    test('siblings are found correctly', () {
      expect(child.siblings, equals(<Tree<String>>[sibling, sibling2]));
    });
    test('we can use find tp find subsequent nodes', () {
      expect(grandparent.find('niece'), equals(niece));
    });
    test('find does not search upwards in tree', () {
      expect(niece.find('root'), equals(null));
    });
  });

  group('Test Forest in tree.dart', () {
    test('Forest roots found correctly', () {
      expect(forest.roots, equals(<Tree<String>>[grandparent, secondRoot]));
    });
    test('Adding root to Forest', () {
      forest.add(secondRoot);
      expect(forest.roots,
          equals(<Tree<String>>[grandparent, secondRoot, secondRoot]));
    });
    test('Flatten forest is breadth-first', () {
      expect(forest.flatten().toList(), equals(expectedForest));
    });
    test('Forest values', () {
      List<String> evals =
          expectedForest.map((Tree<String> f) => f.value).toList();
      expect(forest.values.toList(), equals(evals));
    });
    test('Remove node from Forest, roots unchanged', () {
      forest.remove(parent);
      expect(forest.roots, equals(<Tree<String>>[grandparent, secondRoot]));
    });
    test('Remove node from Forest, node really removed', () {
      forest.remove(parent);
      expect(forest.find('grandparent').find('parent'), equals(null));
    });
    test('Remove root from Forest', () {
      // remove a root
      forest.remove(grandparent);
      // new roots
      expect(forest.roots,
          equals(<Tree<String>>[secondRoot, parent, uncle, aunt]));
    });
    test('Find a node in Forest', () {
      expect(forest.find('sibling'), equals(sibling));
    });
    test('mapForest to Uppercase', () {
      Forest<String> newForest =
          forest.mapForest((String f) => f.toUpperCase());
      expect(newForest.find('NIECE').parent.parent.parent,
          equals(newForest.find('GRANDPARENT')));
    });
  });
}