/*
 * 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 "FCompoundWrite.h"
#import "FImmutableTree.h"
#import "FNamedNode.h"
#import "FNode.h"
#import "FPath.h"
#import "FSnapshotUtilities.h"

@interface FCompoundWrite ()
@property(nonatomic, strong) FImmutableTree *writeTree;
@end

@implementation FCompoundWrite

- (id)initWithWriteTree:(FImmutableTree *)tree {
    self = [super init];
    if (self) {
        self.writeTree = tree;
    }
    return self;
}

+ (FCompoundWrite *)compoundWriteWithValueDictionary:
    (NSDictionary *)dictionary {
    __block FImmutableTree *writeTree = [FImmutableTree empty];
    [dictionary enumerateKeysAndObjectsUsingBlock:^(NSString *pathString,
                                                    id value, BOOL *stop) {
      id<FNode> node = [FSnapshotUtilities nodeFrom:value];
      FImmutableTree *tree = [[FImmutableTree alloc] initWithValue:node];
      writeTree = [writeTree setTree:tree
                              atPath:[[FPath alloc] initWith:pathString]];
    }];
    return [[FCompoundWrite alloc] initWithWriteTree:writeTree];
}

+ (FCompoundWrite *)compoundWriteWithNodeDictionary:(NSDictionary *)dictionary {
    __block FImmutableTree *writeTree = [FImmutableTree empty];
    [dictionary enumerateKeysAndObjectsUsingBlock:^(NSString *pathString,
                                                    id node, BOOL *stop) {
      FImmutableTree *tree = [[FImmutableTree alloc] initWithValue:node];
      writeTree = [writeTree setTree:tree
                              atPath:[[FPath alloc] initWith:pathString]];
    }];
    return [[FCompoundWrite alloc] initWithWriteTree:writeTree];
}

+ (FCompoundWrite *)emptyWrite {
    static dispatch_once_t pred = 0;
    static FCompoundWrite *empty = nil;
    dispatch_once(&pred, ^{
      empty = [[FCompoundWrite alloc]
          initWithWriteTree:[[FImmutableTree alloc] initWithValue:nil]];
    });
    return empty;
}

- (FCompoundWrite *)addWrite:(id<FNode>)node atPath:(FPath *)path {
    if (path.isEmpty) {
        return [[FCompoundWrite alloc]
            initWithWriteTree:[[FImmutableTree alloc] initWithValue:node]];
    } else {
        FTuplePathValue *rootMost =
            [self.writeTree findRootMostValueAndPath:path];
        if (rootMost != nil) {
            FPath *relativePath = [FPath relativePathFrom:rootMost.path
                                                       to:path];
            id<FNode> value = [rootMost.value updateChild:relativePath
                                             withNewChild:node];
            return [[FCompoundWrite alloc]
                initWithWriteTree:[self.writeTree setValue:value
                                                    atPath:rootMost.path]];
        } else {
            FImmutableTree *subtree =
                [[FImmutableTree alloc] initWithValue:node];
            FImmutableTree *newWriteTree = [self.writeTree setTree:subtree
                                                            atPath:path];
            return [[FCompoundWrite alloc] initWithWriteTree:newWriteTree];
        }
    }
}

- (FCompoundWrite *)addWrite:(id<FNode>)node atKey:(NSString *)key {
    return [self addWrite:node atPath:[[FPath alloc] initWith:key]];
}

- (FCompoundWrite *)addCompoundWrite:(FCompoundWrite *)compoundWrite
                              atPath:(FPath *)path {
    __block FCompoundWrite *newWrite = self;
    [compoundWrite.writeTree forEach:^(FPath *childPath, id<FNode> value) {
      newWrite = [newWrite addWrite:value atPath:[path child:childPath]];
    }];
    return newWrite;
}

/**
 * Will remove a write at the given path and deeper paths. This will
 * <em>not</em> modify a write at a higher location, which must be removed by
 * calling this method with that path.
 * @param path The path at which a write and all deeper writes should be
 * removed.
 * @return The new FWriteCompound with the removed path.
 */
- (FCompoundWrite *)removeWriteAtPath:(FPath *)path {
    if (path.isEmpty) {
        return [FCompoundWrite emptyWrite];
    } else {
        FImmutableTree *newWriteTree =
            [self.writeTree setTree:[FImmutableTree empty] atPath:path];
        return [[FCompoundWrite alloc] initWithWriteTree:newWriteTree];
    }
}

/**
 * Returns whether this FCompoundWrite will fully overwrite a node at a given
 * location and can therefore be considered "complete".
 * @param path The path to check for
 * @return Whether there is a complete write at that path.
 */
- (BOOL)hasCompleteWriteAtPath:(FPath *)path {
    return [self completeNodeAtPath:path] != nil;
}

/**
 * Returns a node for a path if and only if the node is a "complete" overwrite
 * at that path. This will not aggregate writes from depeer paths, but will
 * return child nodes from a more shallow path.
 * @param path The path to get a complete write
 * @return The node if complete at that path, or nil otherwise.
 */
- (id<FNode>)completeNodeAtPath:(FPath *)path {
    FTuplePathValue *rootMost = [self.writeTree findRootMostValueAndPath:path];
    if (rootMost != nil) {
        FPath *relativePath = [FPath relativePathFrom:rootMost.path to:path];
        return [rootMost.value getChild:relativePath];
    } else {
        return nil;
    }
}

// TODO: change into traversal method...
- (NSArray *)completeChildren {
    NSMutableArray *children = [[NSMutableArray alloc] init];
    if (self.writeTree.value != nil) {
        id<FNode> node = self.writeTree.value;
        [node enumerateChildrenUsingBlock:^(NSString *key, id<FNode> node,
                                            BOOL *stop) {
          [children addObject:[[FNamedNode alloc] initWithName:key
                                                       andNode:node]];
        }];
    } else {
        [self.writeTree.children
            enumerateKeysAndObjectsUsingBlock:^(
                NSString *childKey, FImmutableTree *childTree, BOOL *stop) {
              if (childTree.value != nil) {
                  [children addObject:[[FNamedNode alloc]
                                          initWithName:childKey
                                               andNode:childTree.value]];
              }
            }];
    }
    return children;
}

// TODO: change into enumarate method
- (NSDictionary *)childCompoundWrites {
    NSMutableDictionary *dict = [NSMutableDictionary dictionary];
    [self.writeTree.children
        enumerateKeysAndObjectsUsingBlock:^(
            NSString *key, FImmutableTree *childWrite, BOOL *stop) {
          dict[key] = [[FCompoundWrite alloc] initWithWriteTree:childWrite];
        }];
    return dict;
}

- (FCompoundWrite *)childCompoundWriteAtPath:(FPath *)path {
    if (path.isEmpty) {
        return self;
    } else {
        id<FNode> shadowingNode = [self completeNodeAtPath:path];
        if (shadowingNode != nil) {
            return [[FCompoundWrite alloc]
                initWithWriteTree:[[FImmutableTree alloc]
                                      initWithValue:shadowingNode]];
        } else {
            return [[FCompoundWrite alloc]
                initWithWriteTree:[self.writeTree subtreeAtPath:path]];
        }
    }
}

- (id<FNode>)applySubtreeWrite:(FImmutableTree *)subtreeWrite
                        atPath:(FPath *)relativePath
                        toNode:(id<FNode>)node {
    if (subtreeWrite.value != nil) {
        // Since a write there is always a leaf, we're done here.
        return [node updateChild:relativePath withNewChild:subtreeWrite.value];
    } else {
        __block id<FNode> priorityWrite = nil;
        __block id<FNode> blockNode = node;
        [subtreeWrite.children
            enumerateKeysAndObjectsUsingBlock:^(
                NSString *childKey, FImmutableTree *childTree, BOOL *stop) {
              if ([childKey isEqualToString:@".priority"]) {
                  // Apply priorities at the end so we don't update priorities
                  // for either empty nodes or forget to apply priorities to
                  // empty nodes that are later filled.
                  NSAssert(childTree.value != nil,
                           @"Priority writes must always be leaf nodes");
                  priorityWrite = childTree.value;
              } else {
                  blockNode = [self
                      applySubtreeWrite:childTree
                                 atPath:[relativePath childFromString:childKey]
                                 toNode:blockNode];
              }
            }];
        // If there was a priority write, we only apply it if the node is not
        // empty
        if (![blockNode getChild:relativePath].isEmpty &&
            priorityWrite != nil) {
            blockNode = [blockNode
                 updateChild:[relativePath childFromString:@".priority"]
                withNewChild:priorityWrite];
        }
        return blockNode;
    }
}

- (void)enumerateWrites:(void (^)(FPath *, id<FNode>, BOOL *))block {
    __block BOOL stop = NO;
    // TODO: add stop to tree iterator...
    [self.writeTree forEach:^(FPath *path, id value) {
      if (!stop) {
          block(path, value, &stop);
      }
    }];
}

/**
 * Applies this FCompoundWrite to a node. The node is returned with all writes
 * from this FCompoundWrite applied to the node.
 * @param node The node to apply this FCompoundWrite to
 * @return The node with all writes applied
 */
- (id<FNode>)applyToNode:(id<FNode>)node {
    return [self applySubtreeWrite:self.writeTree
                            atPath:[FPath empty]
                            toNode:node];
}

/**
 * Return true if this CompoundWrite is empty and therefore does not modify any
 * nodes.
 * @return Whether this CompoundWrite is empty
 */
- (BOOL)isEmpty {
    return self.writeTree.isEmpty;
}

- (id<FNode>)rootWrite {
    return self.writeTree.value;
}

- (BOOL)isEqual:(id)object {
    if (![object isKindOfClass:[FCompoundWrite class]]) {
        return NO;
    }
    FCompoundWrite *other = (FCompoundWrite *)object;
    return
        [[self valForExport:YES] isEqualToDictionary:[other valForExport:YES]];
}

- (NSUInteger)hash {
    return [[self valForExport:YES] hash];
}

- (NSDictionary *)valForExport:(BOOL)exportFormat {
    NSMutableDictionary *dictionary = [NSMutableDictionary dictionary];
    [self.writeTree forEach:^(FPath *path, id<FNode> value) {
      dictionary[path.wireFormat] = [value valForExport:exportFormat];
    }];
    return dictionary;
}

- (NSString *)description {
    return [[self valForExport:YES] description];
}

@end
