/*
 * Copyright 2017 Google
 *
 * 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.
 */

#import "FTree.h"
#import "FPath.h"
#import "FTreeNode.h"
#import "FUtilities.h"

@implementation FTree

@synthesize name;
@synthesize parent;
@synthesize node;

- (id)init {
    self = [super init];
    if (self) {
        self.name = @"";
        self.parent = nil;
        self.node = [[FTreeNode alloc] init];
    }
    return self;
}

- (id)initWithName:(NSString *)aName
        withParent:(FTree *)aParent
          withNode:(FTreeNode *)aNode {
    self = [super init];
    if (self) {
        self.name = aName != nil ? aName : @"";
        self.parent = aParent != nil ? aParent : nil;
        self.node = aNode != nil ? aNode : [[FTreeNode alloc] init];
    }
    return self;
}

- (FTree *)subTree:(FPath *)path {
    FTree *child = self;
    NSString *next = [path getFront];
    while (next != nil) {
        FTreeNode *childNode = child.node.children[next];
        if (childNode == nil) {
            childNode = [[FTreeNode alloc] init];
        }
        child = [[FTree alloc] initWithName:next
                                 withParent:child
                                   withNode:childNode];
        path = [path popFront];
        next = [path getFront];
    }
    return child;
}

- (id)getValue {
    return self.node.value;
}

- (void)setValue:(id)value {
    self.node.value = value;
    [self updateParents];
}

- (void)clear {
    self.node.value = nil;
    [self.node.children removeAllObjects];
    self.node.childCount = 0;
    [self updateParents];
}

- (BOOL)hasChildren {
    return self.node.childCount > 0;
}

- (BOOL)isEmpty {
    return [self getValue] == nil && ![self hasChildren];
}

- (void)forEachChild:(void (^)(FTree *))action {
    for (NSString *key in self.node.children) {
        action([[FTree alloc]
            initWithName:key
              withParent:self
                withNode:[self.node.children objectForKey:key]]);
    }
}

- (void)forEachChildMutationSafe:(void (^)(FTree *))action {
    for (NSString *key in [self.node.children copy]) {
        action([[FTree alloc]
            initWithName:key
              withParent:self
                withNode:[self.node.children objectForKey:key]]);
    }
}

- (void)forEachDescendant:(void (^)(FTree *))action {
    [self forEachDescendant:action includeSelf:NO childrenFirst:NO];
}

- (void)forEachDescendant:(void (^)(FTree *))action
              includeSelf:(BOOL)incSelf
            childrenFirst:(BOOL)childFirst {
    if (incSelf && !childFirst) {
        action(self);
    }

    [self forEachChild:^(FTree *child) {
      [child forEachDescendant:action includeSelf:YES childrenFirst:childFirst];
    }];

    if (incSelf && childFirst) {
        action(self);
    }
}

- (BOOL)forEachAncestor:(BOOL (^)(FTree *))action {
    return [self forEachAncestor:action includeSelf:NO];
}

- (BOOL)forEachAncestor:(BOOL (^)(FTree *))action includeSelf:(BOOL)incSelf {
    FTree *aNode = (incSelf) ? self : self.parent;
    while (aNode != nil) {
        if (action(aNode)) {
            return YES;
        }
        aNode = aNode.parent;
    }
    return NO;
}

- (void)forEachImmediateDescendantWithValue:(void (^)(FTree *))action {
    [self forEachChild:^(FTree *child) {
      if ([child getValue] != nil) {
          action(child);
      } else {
          [child forEachImmediateDescendantWithValue:action];
      }
    }];
}

- (BOOL)valueExistsAtOrAbove:(FPath *)path {
    FTreeNode *aNode = self.node;
    while (aNode != nil) {
        if (aNode.value != nil) {
            return YES;
        }
        aNode = [aNode.children objectForKey:path.getFront];
        path = [path popFront];
    }
    // XXX Check with Michael if this is correct; deviates from JS.
    return NO;
}

- (FPath *)path {
    return [[FPath alloc]
        initWith:(self.parent == nil)
                     ? self.name
                     : [NSString stringWithFormat:@"%@/%@", [self.parent path],
                                                  self.name]];
}

- (void)updateParents {
    [self.parent updateChild:self.name withNode:self];
}

- (void)updateChild:(NSString *)childName withNode:(FTree *)child {
    BOOL childEmpty = [child isEmpty];
    BOOL childExists = self.node.children[childName] != nil;
    if (childEmpty && childExists) {
        [self.node.children removeObjectForKey:childName];
        self.node.childCount = self.node.childCount - 1;
        [self updateParents];
    } else if (!childEmpty && !childExists) {
        [self.node.children setObject:child.node forKey:childName];
        self.node.childCount = self.node.childCount + 1;
        [self updateParents];
    }
}

@end
