//
//  ReconTableView.m
//  Unison
//
//  Created by Trevor Jim on Wed Aug 27 2003.
//  Copyright (c) 2003, 2016.  See file COPYING for details.
//

#import "ReconTableView.h"
#import "ReconItem.h"
#import "MyController.h"

@implementation NSOutlineView (_UnisonExtras)

- (NSArray *)selectedObjects
{
        NSMutableArray *result = [NSMutableArray array];
  NSIndexSet *set = [self selectedRowIndexes];
  NSUInteger index = [set firstIndex];
  while (index != NSNotFound) {
    [result addObject:[self itemAtRow:index]];
    index = [set indexGreaterThanIndex: index];
  }
  return result;
}

- (void)setSelectedObjects:(NSArray *)selectedObjects
{
        NSMutableIndexSet *set = [NSMutableIndexSet indexSet];
        NSUInteger i = [selectedObjects count];
        while (i--) {
                NSInteger index = [self rowForItem:[selectedObjects objectAtIndex:i]];
                if (index >= 0)	[set addIndex:index];
        }
        [self selectRowIndexes:set byExtendingSelection:NO];
}

- (NSEnumerator *)selectedObjectEnumerator
{
        return [[self selectedObjects] objectEnumerator];
}

- (int)rowCapacityWithoutScrolling
{
        float bodyHeight = [self visibleRect].size.height;
        bodyHeight -=  [[self headerView] visibleRect].size.height;
        return bodyHeight / ([self rowHeight] + 2.0);
}

- (BOOL)_canAcceptRowCountWithoutScrolling:(NSInteger)rows
{
        return ([self numberOfRows] + rows) <= [self rowCapacityWithoutScrolling];
}

- (BOOL)_expandChildrenIfSpace:(id)parent level:(int)level
{
        BOOL didExpand = NO;
        id dataSource = [self dataSource];
        NSInteger count = [dataSource outlineView:self numberOfChildrenOfItem:parent];
        if (level == 0) {
                if (count && ([self isItemExpanded:parent] || [self _canAcceptRowCountWithoutScrolling:count])) {
                        [self expandItem:parent expandChildren:NO];
                        didExpand = YES;
                }
        } else {
                // try expanding each of our children.  If all expand, then return YES,
                // indicating that it may be worth trying the next level
                int i;
                for (i=0; i < count; i++) {
                        id child = [dataSource outlineView:self child:i ofItem:parent];
                        didExpand = [self _expandChildrenIfSpace:child level:level-1] || didExpand;
                }
        }

        return didExpand;
}

- (void)expandChildrenIfSpace
{
        int level = 1;
        while ([self _expandChildrenIfSpace:nil level:level]) level++;
}

@end

@implementation ReconTableView

- (BOOL)editable
{
    return editable;
}

- (void)setEditable:(BOOL)x
{
    editable = x;
}

- (BOOL)validateItem:(SEL) action
{
    if (action == @selector(selectAll:)
        || action == @selector(selectConflicts:)
        || action == @selector(copyLR:)
        || action == @selector(copyRL:)
        || action == @selector(leaveAlone:)
        || action == @selector(forceNewer:)
        || action == @selector(forceOlder:)
        || action == @selector(revert:)
        || action == @selector(ignorePath:)
        || action == @selector(ignoreExt:)
        || action == @selector(ignoreName:))
        return editable;
    else if (action == @selector(merge:)) {
        if (!editable) return NO;
        else return [self canDiffSelection];
    }
    else if (action == @selector(showDiff:)) {
        if ((!editable) || (!([self numberOfSelectedRows]==1)))
            return NO;
        else return [self canDiffSelection];
    }
    else return YES;
}

- (BOOL)validateMenuItem:(NSMenuItem *)menuItem
{
        return [self validateItem:[menuItem action]];
}

- (BOOL)validateToolbarItem:(NSToolbarItem *)toolbarItem
{
       return [self validateItem:[toolbarItem action]];
}

- (void)doIgnore:(unichar)c
{
    NSEnumerator *e = [self selectedObjectEnumerator];
        ReconItem *item, *last = nil;
    while (item = [e nextObject]) {
        [item doIgnore:c];
                last = item;
    }
    if (last) { // something was selected
        MyController* controller = (MyController*) [self dataSource];
        last = [controller updateForIgnore:last];
        [self selectRowIndexes:[NSIndexSet indexSetWithIndex:[self rowForItem:last]] byExtendingSelection:NO];
        [self reloadData];
    }
}

- (IBAction)ignorePath:(id)sender
{
    [self doIgnore:'I'];
}

- (IBAction)ignoreExt:(id)sender
{
    [self doIgnore:'E'];
}

- (IBAction)ignoreName:(id)sender
{
    [self doIgnore:'N'];
}

- (void)doAction:(unichar)c
{
    int numSelected = 0;
    NSEnumerator *e = [self selectedObjectEnumerator];
        ReconItem *item, *last = nil;
    while (item = [e nextObject]) {
        numSelected++;
        [item doAction:c];
                last = item;
    }
    if (numSelected>0) {
                long nextRow = [self rowForItem:last] + 1;
        if (numSelected == 1 && [self numberOfRows] > nextRow && c!='d') {
            // Move to next row, unless already at last row, or if more than one row selected
            [self selectRowIndexes:[NSIndexSet indexSetWithIndex:nextRow] byExtendingSelection:NO];
            [self scrollRowToVisible:nextRow];
        }
        [self reloadData];
    }
}

- (IBAction)copyLR:(id)sender
{
    [self doAction:'>'];
}

- (IBAction)copyRL:(id)sender
{
    [self doAction:'<'];
}

- (IBAction)leaveAlone:(id)sender
{
    [self doAction:'/'];
}

- (IBAction)forceOlder:(id)sender
{
    [self doAction:'-'];
}

- (IBAction)forceNewer:(id)sender
{
    [self doAction:'+'];
}

- (IBAction)selectConflicts:(id)sender
{
    [self deselectAll:self];
    MyController* controller = (MyController*) [self dataSource];
    NSMutableArray *reconItems = [controller reconItems];
    int i = 0;
    for (; i < [reconItems count]; i++) {
                ReconItem *item = [reconItems objectAtIndex:i];
        if ([item isConflict])
            [self selectRowIndexes:[NSIndexSet indexSetWithIndex:[self rowForItem:item]] byExtendingSelection:YES];
    }
}

- (IBAction)revert:(id)sender
{
    [self doAction:'R'];
}

- (IBAction)merge:(id)sender
{
    [self doAction:'m'];
}

- (IBAction)showDiff:(id)sender
{
    [self doAction:'d'];
}

/* There are menu commands for these, but we add some shortcuts so you don't
   have to press the Command key */
- (void)keyDown:(NSEvent *)event
{
    /* some keys return zero-length strings */
    if ([[event characters] length] == 0) {
        [super keyDown:event];
        return;
    }

    /* actions are disabled when when menu items are */
    if (!editable) {
        [super keyDown:event];
        return;
    }

    unichar c = [[event characters] characterAtIndex:0];
    switch (c) {
    case '>':
    case NSRightArrowFunctionKey:
        [self doAction:'>'];
        break;
    case '<':
    case NSLeftArrowFunctionKey:
        [self doAction:'<'];
        break;
    case '?':
    case '/':
        [self doAction:'/'];
        break;
    default:
        [super keyDown:event];
        break;
    }
}

- (BOOL)canDiffSelection
{
    BOOL canDiff = YES;
    NSEnumerator *e = [self selectedObjectEnumerator];
        ReconItem *item;
    while (item = [e nextObject]) {
        if (![item canDiff]) canDiff= NO;
    }
    return canDiff;
}

/* Override default highlight colour because it's hard to see the
   conflict/resolution icons */
- (id)_highlightColorForCell:(NSCell *)cell
{
    if(([[self window] firstResponder] == self) &&
        [[self window] isMainWindow] &&
        [[self window] isKeyWindow])

        return [NSColor colorWithCalibratedRed:0.7 green:0.75 blue:0.8 alpha:1.0];
    else return [NSColor colorWithCalibratedRed:0.8 green:0.8 blue:0.8 alpha:1.0];
}

@end
