@implementation ScoreController

#pragma mark Selection methods

- (void) selectAll {
    [[[[NSApp delegate] activeTrack] selection] selectAllWithUndo: NO];

    [[NSApp delegate] redisplay: [NSSet setWithObjects: ScoreSelectionID, LCDBarViewID, TrackViewID, nil] withUndo: NO];
}

- (void) moveSelection: (Direction)direction withInsert: (BOOL)insert undo: (BOOL)undo {
    Selection* selection = [[[NSApp delegate] activeTrack] selection];
    
    // Possibly insert a division or measure and move the selection.
    if (insert && (direction == Left || direction == Right) && selection.mode == NoteSelectionMode) {
        // Check if we're moving out of the measure.
        BOOL leavingMeasure = ((direction == Right && [selection.start isLastDivisionInMeasure]) ||
                               (direction == Left  && [selection.start isFirstDivisionInMeasure]));
        
        // Insert a new division or measure if necessary.
        if (selection.start.measure.relativeDuration < 1.0) {
            [self insertDivisionAtSelectionWithDirection: direction];
        }
        else if (leavingMeasure && [selection.start.measure isLastMeasureInTrack]) {
            [self insertMeasureAtSelectionWithDirection: direction];
        }
        else {
            [selection move: direction withUndo: undo];
        }
    }
    else {
        [selection move: direction withUndo: undo];
    }
    
    // Scroll the score.
    [scoreView scrollSoMeasureIsVisible: selection.start.measure overTime: SelectionMoveScrollTime];
    
    [[NSApp delegate] redisplay: [NSSet setWithObjects: ScoreSelectionID, LCDBarViewID, TrackViewID, nil] withUndo: undo];
}

- (void) moveSelectionByMeasure: (Direction)direction withUndo: (BOOL)undo {
    Selection* selection = [[[NSApp delegate] activeTrack] selection];
    NSArray* measures    = [[[NSApp delegate] activeTrack] measures];
    Measure* start       = selection.start.measure;
    
    // Figure out which measure we want.
    Measure* newMeasure;
    
    switch (direction) {
        case Right: newMeasure = (start == measures.lastObject) ? [measures objectAtIndex: 0] : start.nextMeasure;     break;
        case Left:  newMeasure = (start == [measures objectAtIndex: 0]) ? measures.lastObject : start.previousMeasure; break;
        default:    return;
    }
    
    // Set the selection.
    [selection moveToMeasure: newMeasure withUndo: undo];
    
    // Scroll the score.
    [scoreView scrollSoMeasureIsVisible: selection.start.measure overTime: SelectionMoveScrollTime];
    
    [[NSApp delegate] redisplay: [NSSet setWithObjects: ScoreSelectionID, LCDBarViewID, TrackViewID, nil] withUndo: undo];
}

- (void) selectCurrentDivision {
    Selection* selection = [[[NSApp delegate] activeTrack] selection];
    
    // Beep and return if we're already in division selection mode.
    // TODO: Disable the menu item so that this can't happen.
    if (selection.mode == DivisionSelectionMode) {
        NSBeep();
        return;
    }
    
    // Select the current division.
    [selection selectFrom: selection.start to: selection.start withUndo: NO];
    
    [[NSApp delegate] redisplay: [NSSet setWithObjects: ScoreSelectionID, TrackViewID, nil] withUndo: NO];
}

- (void) selectDivisionAt: (NSPoint)p {
    DivisionLayout* divisionLayout = [scoreView.layout divisionLayoutAt: p];
    
    // If we clicked a division, select it.
    if (divisionLayout) {
        RowLayout* rowLayout = divisionLayout.measureLayout.rowLayout;
        
        // Keep track of the anchor division.
        anchorDivision = divisionLayout.division;
        
        // Figure out which string we selected.
        int string = (p.y - rowLayout.tabPosition + TabSpaceHeight / 2.0) / TabSpaceHeight;
        string     = clampToRange(string, 0, [[[NSApp delegate] activeTrack] stringCount] - 1);
        
        // Make the selection and scroll the score.
        [[[[NSApp delegate] activeTrack] selection] selectString: string ofDivision: anchorDivision withUndo: NO];
        [scoreView scrollSoMeasureIsVisible: anchorDivision.measure overTime: SelectionMoveScrollTime];
        
        [[NSApp delegate] redisplay: [NSSet setWithObjects: ScoreSelectionID, LCDBarViewID, TrackViewID, nil] withUndo: NO];
    }
}

- (void) jumpToString: (int)string {
    Track* track = [[NSApp delegate] activeTrack];
    
    // Beep if we're trying to jump to a non-existant string.
    if (string < track.stringCount) {
        [track.selection selectString: string withUndo: NO];
    }
    else {
        NSBeep();
    }
    
    [[NSApp delegate] redisplayView: ScoreSelectionID withUndo: NO];
}

- (void) startDragSelect {
    // Just set the flag.
    isPerformingDragSelect = YES;
}

- (void) updateDragSelectAt: (NSPoint)p {
    // Update the selection.
    Selection* selection = [[[NSApp delegate] activeTrack] selection];
    [selection selectFrom: anchorDivision to: [scoreView.layout divisionLayoutAt: p].division withUndo: NO];
    
    [[NSApp delegate] redisplay: [NSSet setWithObjects: ScoreSelectionID, LCDBarViewID, TrackViewID, nil] withUndo: NO];
}

- (void) endDragSelect {
    isPerformingDragSelect = NO;
}

- (void) resizeSelectionWithDirection: (Direction)direction {
    [[[[NSApp delegate] activeTrack] selection] resizeSelectionInDirection: direction withUndo: NO];
    
    [[NSApp delegate] redisplay: [NSSet setWithObjects: ScoreSelectionID, LCDBarViewID, TrackViewID, nil] withUndo: NO];
}

#pragma mark Selection operations

- (void) setSelectionDuration: (NoteDuration)duration {
    NSUndoManager* undoManager = [[NSApp delegate] undoManager];
    
    // Keep track of whether we modified anything.
    __block BOOL modified = NO;
    
    [[[[NSApp delegate] activeTrack] selection] collectDivisionsWithBlock: ^(Division* division) {
        // Skip notes that already have this duration.
        if (division.baseDuration != duration) {
            if (!modified) {
                [[NSApp delegate] redisplay: [NSSet setWithObjects: ScoreViewID, LCDBarViewID, nil] withUndo: YES];
                modified = YES;
            }
            
            // Set up undo.
            [[undoManager prepareWithInvocationTarget: division] setBaseDuration: division.baseDuration];
            
            // Set the division's duration.
            [division setBaseDurationWithUndo: duration];
        }
    }];
    
    // Beep if we didn't modify anything.
    if (!modified) {
        NSBeep();
        return;
    }
    
    // Set undo action name.
    [[NSApp delegate] setUndoActionName: @"Set Note Durations" withMessage: NO];
}

- (void) modifySelectionDuration: (int)difference {
    // TODO: Refactor so that this method calls setSelectionDuration.
    NSUndoManager* undoManager = [[NSApp delegate] undoManager];
    
    // Keep track of whether we actually modified any divisions.
    __block BOOL modified = NO;
    
    [[[[NSApp delegate] activeTrack] selection] collectDivisionsWithBlock: ^(Division* division) {
        int oldDuration = (int)division.baseDuration;
        int newDuration = clampToRange(oldDuration + difference, SixtyFourthNote, WholeNote);
        
        // Make sure the new duration is different so we can keep track of whether we modified any divisions.
        if (oldDuration != newDuration) {
            if (!modified) {
                [[NSApp delegate] redisplay: [NSSet setWithObjects: ScoreViewID, LCDBarViewID, nil] withUndo: YES];
                modified = YES;
            }
            
            // Set up undo.
            [[undoManager prepareWithInvocationTarget: division] setBaseDuration: oldDuration];
            
            // Set the duration.
            [division setBaseDurationWithUndo: newDuration];
        }
    }];
    
    // Beep if they can't modify the duration.
    if (!modified) {
        NSBeep();
        return;
    }
    
    // Set undo action name.
    NSString* actionName = (difference > 0) ? @"Increase Note Durations" : @"Decrease Note Durations";
    [[NSApp delegate] setUndoActionName: actionName withMessage: NO];
}

- (void) setSelectionToRests {
    [[[[NSApp delegate] activeTrack] selection] collectDivisionsWithBlock: ^(Division* division) {
        [division makeRestWithUndo: YES];
    }];
    
    [[NSApp delegate] redisplay: [NSSet setWithObjects: ScoreViewID, LCDBarViewID, TrackViewID, nil] withUndo: YES];
}

- (void) insertDivisionAtSelectionWithDirection: (Direction)direction {
    Selection* selection = [[[NSApp delegate] activeTrack] selection];
    int currentIndex     = [selection.start.measure.divisions indexOfObject: selection.start];
    
    // Beep and return if we're in division-selection mode.
    if (selection.mode == DivisionSelectionMode) {
        NSBeep();
        return;
    }
    
    // Add the division.
    int newIndex;
    
    switch (direction) {
        case Left:  newIndex = fmax(0, currentIndex - 1); break;
        case Right: newIndex = currentIndex + 1;          break;
        default:    return;
    }
    
    [selection.start.measure addDivisionAtIndex: newIndex withUndo: YES];
    
    // Select the new division.
    [selection selectDivision: [selection.start.measure.divisions objectAtIndex: newIndex] withUndo: YES];
    
    // Set up undo.
    [[NSApp delegate] setUndoActionName: @"Create Division" withMessage: NO];
    
    [[NSApp delegate] redisplay: [NSSet setWithObjects: ScoreViewID, LCDBarViewID, PaletteID, nil] withUndo: YES];
}

- (void) insertMeasureAtSelectionWithDirection: (Direction)direction {
    Selection* selection = [[[NSApp delegate] activeTrack] selection];
    NSArray* measures    = [[[NSApp delegate] activeTrack] measures];
    int currentIndex     = [measures indexOfObject: selection.start.measure];
    
    // Beep and return if we're in division-selection mode.
    if (selection.mode == DivisionSelectionMode) {
        NSBeep();
        return;
    }
    
    // Add the measure.
    int newIndex;
    
    switch (direction) {
        case Left:  newIndex = fmax(0, currentIndex - 1); break;
        case Right: newIndex = currentIndex + 1;          break;
        default:    return;
    }
    
    [[[NSApp delegate] activeScore] addMeasureAtIndex: newIndex withUndo: YES];
    
    // Select the new measure.
    [selection moveToMeasure: [measures objectAtIndex: newIndex] withUndo: YES];
    
    // Set up undo.
    [[NSApp delegate] setUndoActionName: @"Create Measure" withMessage: NO];
    
    [[NSApp delegate] redisplay: [NSSet setWithObjects: ScoreViewID, LCDBarViewID, TrackViewID, PaletteID, nil] withUndo: YES];
}

- (void) removeSelection {
    Selection* selection = [[[NSApp delegate] activeTrack] selection];
    
    // Perform the deletion based on the selection mode.
    if (selection.mode == DivisionSelectionMode) {
        [self removeSelectedDivisions];
    }
    else if (selection.mode == NoteSelectionMode) {
        // Delete the current note.
        [selection removeSelectedNoteWithUndo: YES];
        
        // Set the undo action name.
        [[NSApp delegate] setUndoActionName: @"Delete Note" withMessage: NO];
        
        [[NSApp delegate] redisplay: [NSSet setWithObjects: ScoreViewID, LCDBarViewID, TrackViewID, nil] withUndo: YES];
    }
}

- (void) removeSelectedDivisions {
    Selection* selection            = [[[NSApp delegate] activeTrack] selection];
    BOOL selectingMultipleDivisions = (selection.start != selection.end);
    
    // Delete the selected divisions.
    [selection removeSelectedDivisionsWithUndo: YES];
    
    // Set the undo action name.
    NSString* actionName = (selectingMultipleDivisions) ? @"Delete Divisions" : @"Delete Division";
    [[NSApp delegate] setUndoActionName: actionName withMessage: YES];
    
    [[NSApp delegate] redisplay: [NSSet setWithObjects: ScoreViewID, LCDBarViewID, TrackViewID, nil] withUndo: YES];
}

- (void) removeSelectedMeasures {
    Selection* selection           = [[[NSApp delegate] activeTrack] selection];
    BOOL selectingMultipleMeasures = (selection.start.measure != selection.end.measure);
    
    // Delete the selected measures and redisplay.
    [selection removeSelectedMeasuresWithUndo: YES];
    
    // Set the undo action name.
    NSString* actionName = (selectingMultipleMeasures) ? @"Delete Measures" : @"Delete Measure";
    [[NSApp delegate] setUndoActionName: actionName withMessage: YES];
    
    [[NSApp delegate] redisplay: [NSSet setWithObjects: ScoreViewID, LCDBarViewID, TrackViewID, nil] withUndo: YES];
}

- (void) transposeSelectionBy: (int)semitones {
    Selection* selection = [[[NSApp delegate] activeTrack] selection];
    
    // First we need to check if we're able to transpose every note in the selection.
    __block BOOL canTranspose     = YES;
    __block BOOL isEmptySelection = YES;
    
    [selection collectNonEmptyNotesWithBlock: ^(Note* note, int string) {
        // We are a non-empty selection if we reach this point.
        isEmptySelection = NO;
        
        // We can't transpose open notes downwards, and we can't transpose notes above the max fret number.
        if (!isInRange([note.division fretOnString: string] + semitones, 0, MaxFretNumber)) {
            canTranspose = NO;
        }
    }];
    
    // Beep and return if we can't transpose.
    if (!canTranspose || isEmptySelection) {
        NSBeep();
        return;
    }
    
    // We can transpose, so let's do it.
    [selection collectDivisionsWithBlock: ^(Division* division) {
        for (int i = 0; i < division.notes.count; i++) {
            Note* note = [division.notes objectAtIndex: i];
            
            // Make sure we're transposing a note within the selection, and that the note isn't empty.
            if ((selection.mode == DivisionSelectionMode || i == selection.selectedString) && ![note isEmpty]) {
                // Transpose.
                // TODO: Pass in the actual key.
                [note transposeBy: semitones inKey: nil withUndo: YES];
            }
        }
    }];
    
    // Set undo action name.
    [[NSApp delegate] setUndoActionName: @"Transpose Selection" withMessage: NO];
    
    [[NSApp delegate] redisplay: [NSSet setWithObjects: ScoreViewID, LCDBarViewID, nil] withUndo: YES];
}

#pragma mark Miscellaneous methods

- (void) scrollToSelection {
    Selection* selection = [[[NSApp delegate] activeTrack] selection];
    [scoreView scrollToMeasure: selection.start.measure overTime: SelectionMoveScrollTime];
}

- (BOOL) validateMenuItem: (NSMenuItem*)item {
    // All of our menu items should only be active if there is an open document.
    return ([[NSApp delegate] activeDocument] != nil);
}

@end