/*****************************************************************************
 * VLCLibraryMenuController.m: MacOS X interface module
 *****************************************************************************
 * Copyright (C) 2019 VLC authors and VideoLAN
 *
 * Authors: Felix Paul Kühne <fkuehne # videolan -dot- org>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
 *****************************************************************************/

#import "VLCLibraryMenuController.h"

#import "extensions/NSMenu+VLCAdditions.h"
#import "extensions/NSMenuItem+VLCAdditions.h"
#import "extensions/NSString+Helpers.h"

#import "library/VLCInputItem.h"
#import "library/VLCLibraryAddToPlaylistMenuController.h"
#import "library/VLCLibraryController.h"
#import "library/VLCLibraryModel.h"
#import "library/VLCLibraryRepresentedItem.h"
#import "library/VLCLibrarySegment.h"
#import "library/VLCLibraryWindow.h"

#import "main/VLCMain.h"

#import "panels/VLCInformationWindowController.h"

#import "playqueue/VLCPlayQueueController.h"

#import <vlc_input.h>
#import <vlc_url.h>
#import <vlc_common.h>

@interface VLCLibraryMenuController ()
{
    VLCInformationWindowController *_informationWindowController;

    NSHashTable<NSMenuItem*> *_mediaItemRequiringMenuItems;
    NSHashTable<NSMenuItem*> *_recentsMediaItemRequiringMenuItems;
    NSHashTable<NSMenuItem*> *_inputItemRequiringMenuItems;
    NSHashTable<NSMenuItem*> *_localInputItemRequiringMenuItems;
    NSHashTable<NSMenuItem*> *_folderInputItemRequiringMenuItems;

    NSMenuItem *_revealItem;
    NSMenuItem *_deleteItem;
    NSMenuItem *_removeFromPlaylistItem;
    NSMenuItem *_informationItem;
    NSMenuItem *_renamePlaylistItem;

    VLCLibraryAddToPlaylistMenuController *_addToPlaylistMenuController;
    NSMenuItem *_addToPlaylistItem;
}

@property (readwrite) NSMenuItem *favoriteItem;

@end

@implementation VLCLibraryMenuController

- (instancetype)init
{
    self = [super init];
    if (self) {
        [self createLibraryMenu];
    }
    return self;
}

- (void)createLibraryMenu
{
    NSMenuItem *playItem = [[NSMenuItem alloc] initWithTitle:_NS("Play") action:@selector(play:) keyEquivalent:@""];
    playItem.target = self;

    NSMenuItem *appendItem = [[NSMenuItem alloc] initWithTitle:_NS("Append to Play Queue") action:@selector(appendToPlayQueue:) keyEquivalent:@""];
    appendItem.target = self;

    NSMenuItem *addItem = [[NSMenuItem alloc] initWithTitle:_NS("Add Media Folder...") action:@selector(addMedia:) keyEquivalent:@""];
    addItem.target = self;

    _revealItem = [[NSMenuItem alloc] initWithTitle:_NS("Reveal in Finder") action:@selector(revealInFinder:) keyEquivalent:@""];
    _revealItem.target = self;

    _deleteItem = [[NSMenuItem alloc] initWithTitle:_NS("Move to Trash") action:@selector(moveToTrash:) keyEquivalent:@""];
    _deleteItem.target = self;

    NSMenuItem *markUnseenItem = [[NSMenuItem alloc] initWithTitle:_NS("Mark as Unseen") action:@selector(markUnseen:) keyEquivalent:@""];
    markUnseenItem.target = self;

    _informationItem = [[NSMenuItem alloc] initWithTitle:_NS("Information...") action:@selector(showInformation:) keyEquivalent:@""];
    _informationItem.target = self;

    NSMenuItem * const bookmarkItem = [[NSMenuItem alloc] initWithTitle:_NS("Toggle Bookmark")
                                                                 action:@selector(toggleBookmark:)
                                                          keyEquivalent:@""];
    bookmarkItem.target = self;

    NSMenuItem * const addToLibraryItem = [[NSMenuItem alloc] initWithTitle:_NS("Add to Media Library")
                                                                      action:@selector(addToMediaLibrary:)
                                                               keyEquivalent:@""];
    addToLibraryItem.target = self;

    _favoriteItem = [[NSMenuItem alloc] initWithTitle:_NS("Toggle Favorite") action:@selector(toggleFavorite:) keyEquivalent:@""];
    self.favoriteItem.target = self;

    _addToPlaylistMenuController = [[VLCLibraryAddToPlaylistMenuController alloc] init];
    _addToPlaylistItem = [_addToPlaylistMenuController createAddToPlaylistMenuItem];

    _removeFromPlaylistItem = [[NSMenuItem alloc] initWithTitle:_NS("Remove from Playlist")
                                                         action:@selector(removeFromPlaylist:)
                                                  keyEquivalent:@""];
    _removeFromPlaylistItem.target = self;

    _renamePlaylistItem = [[NSMenuItem alloc] initWithTitle:_NS("Rename playlist")
                                                     action:@selector(renamePlaylist:)
                                              keyEquivalent:@""];
    _renamePlaylistItem.target = self;

    [playItem vlc_setActionImageWithSystemSymbolName:@"play.fill"];
    [appendItem vlc_setActionImageWithSystemSymbolName:@"text.line.last.and.arrowtriangle.forward"];
    [_removeFromPlaylistItem vlc_setActionImageWithSystemSymbolName:@"minus.circle"];
    [_renamePlaylistItem vlc_setActionImageWithSystemSymbolName:@"pencil"];
    [self.favoriteItem vlc_setActionImageWithSystemSymbolName:@"heart"];
    [bookmarkItem vlc_setActionImageWithSystemSymbolName:@"bookmark"];
    [addToLibraryItem vlc_setActionImageWithSystemSymbolName:@"plus.rectangle.on.folder"];
    [_revealItem vlc_setActionImageWithSystemSymbolName:@"folder"];
    [_deleteItem vlc_setActionImageWithSystemSymbolName:@"trash"];
    [markUnseenItem vlc_setActionImageWithSystemSymbolName:@"eye.slash"];
    [_informationItem vlc_setActionImageWithSystemSymbolName:@"info.circle"];
    [addItem vlc_setActionImageWithSystemSymbolName:@"folder.badge.plus"];

    _libraryMenu = [[NSMenu alloc] initWithTitle:@""];
    [_libraryMenu addMenuItemsFromArray:@[
        playItem,
        appendItem,
        _addToPlaylistItem,
        _renamePlaylistItem,
        self.favoriteItem,
        bookmarkItem,
        addToLibraryItem,
        _revealItem,
        _removeFromPlaylistItem,
        _deleteItem,
        markUnseenItem,
        _informationItem,
        [NSMenuItem separatorItem],
        addItem
    ]];

    _mediaItemRequiringMenuItems = [NSHashTable weakObjectsHashTable];
    [_mediaItemRequiringMenuItems addObject:playItem];
    [_mediaItemRequiringMenuItems addObject:appendItem];
    [_mediaItemRequiringMenuItems addObject:_addToPlaylistItem];
    [_mediaItemRequiringMenuItems addObject:self.favoriteItem];
    [_mediaItemRequiringMenuItems addObject:_revealItem];
    [_mediaItemRequiringMenuItems addObject:_deleteItem];
    [_mediaItemRequiringMenuItems addObject:_informationItem];

    _recentsMediaItemRequiringMenuItems = [NSHashTable weakObjectsHashTable];
    [_recentsMediaItemRequiringMenuItems addObject:markUnseenItem];

    _inputItemRequiringMenuItems = [NSHashTable weakObjectsHashTable];
    [_inputItemRequiringMenuItems addObject:playItem];
    [_inputItemRequiringMenuItems addObject:appendItem];

    _localInputItemRequiringMenuItems = [NSHashTable weakObjectsHashTable];
    [_localInputItemRequiringMenuItems addObject:_revealItem];
    [_localInputItemRequiringMenuItems addObject:_deleteItem];

    _folderInputItemRequiringMenuItems = [NSHashTable weakObjectsHashTable];
    [_folderInputItemRequiringMenuItems addObject:bookmarkItem];
    [_folderInputItemRequiringMenuItems addObject:addToLibraryItem];
}

- (void)menuItems:(NSHashTable<NSMenuItem*>*)menuItems
        setHidden:(BOOL)hidden
{
    for (NSMenuItem * const menuItem in menuItems) {
        menuItem.hidden = hidden;
    }
}

- (BOOL)representedItemHasInformationTarget:(VLCLibraryRepresentedItem * const)representedItem
{
    id<VLCMediaLibraryItemProtocol> const item = representedItem.item;

    if ([item isKindOfClass:VLCMediaLibraryPlaylist.class]) {
        return ((VLCMediaLibraryPlaylist *)item).numberOfMedia > 0;
    }

    return item.mediaItems.count > 0;
}

- (BOOL)representedItemsCanBeRevealedInFinder
{
    for (VLCLibraryRepresentedItem * const representedItem in self.representedItems) {
        id<VLCMediaLibraryItemProtocol> const item = representedItem.item;
        if ([item isKindOfClass:VLCMediaLibraryPlaylist.class] &&
            ((VLCMediaLibraryPlaylist *)item).MRL.length == 0) {
            return NO;
        }
    }

    return self.representedItems.count > 0;
}

- (void)updateMenuItems
{
    VLCLibraryModel * const libraryModel = VLCMain.sharedInstance.libraryController.libraryModel;
    NSArray<VLCMediaLibraryMediaItem *> * const recents = libraryModel.listOfRecentMedia;
    const BOOL isFavoritesSegment =
        VLCMain.sharedInstance.libraryWindow.librarySegmentType == VLCLibraryFavoritesSegmentType;

    _removeFromPlaylistItem.hidden = YES;
    _renamePlaylistItem.hidden = YES;

    /* no represented items (right-click on empty space) - media actions are disabled */
    if (self.representedItems.count == 0 && self.representedInputItems.count == 0) {
        [self menuItems:_inputItemRequiringMenuItems setHidden:YES];
        [self menuItems:_localInputItemRequiringMenuItems setHidden:YES];
        [self menuItems:_folderInputItemRequiringMenuItems setHidden:YES];
        [self menuItems:_recentsMediaItemRequiringMenuItems setHidden:YES];
        [self menuItems:_mediaItemRequiringMenuItems setHidden:NO];
        _revealItem.hidden = NO;
        self.favoriteItem.hidden = isFavoritesSegment;
        return;
    }

    if (self.representedItems != nil && self.representedItems.count > 0) {
        [self menuItems:_inputItemRequiringMenuItems setHidden:YES];
        [self menuItems:_localInputItemRequiringMenuItems setHidden:YES];
        [self menuItems:_folderInputItemRequiringMenuItems setHidden:YES];
        [self menuItems:_mediaItemRequiringMenuItems setHidden:NO];
        _revealItem.hidden = ![self representedItemsCanBeRevealedInFinder];

        BOOL allInPlaylist = YES;
        for (VLCLibraryRepresentedItem * const item in self.representedItems) {
            if (item.parentType != VLCMediaLibraryParentGroupTypePlaylist ||
                ![item.item isKindOfClass:VLCMediaLibraryMediaItem.class] ||
                item.parentItem == nil ||
                item.positionInParent == NSNotFound) {
                allInPlaylist = NO;
                break;
            }
        }
        _removeFromPlaylistItem.hidden = !allInPlaylist;
        if (self.representedItems.count == 1 &&
            [self.representedItems.firstObject.item isKindOfClass:VLCMediaLibraryPlaylist.class]) {
            VLCMediaLibraryPlaylist * const playlist =
                (VLCMediaLibraryPlaylist *)self.representedItems.firstObject.item;
            _renamePlaylistItem.hidden = playlist.readOnly;
        }

        BOOL anyNonRecent = NO;
        for (VLCLibraryRepresentedItem * const item in self.representedItems) {
            if ([recents indexOfObjectPassingTest:^BOOL(VLCMediaLibraryMediaItem * _Nonnull obj, NSUInteger __unused idx, BOOL * __unused stop) {
                return obj.libraryID == item.item.libraryID;
            }] == NSNotFound) {
                anyNonRecent = YES;
                break;
            }
        }
        [self menuItems:_recentsMediaItemRequiringMenuItems setHidden:anyNonRecent];
        
        BOOL anyUnfavorited = NO;
        for (VLCLibraryRepresentedItem * const item in self.representedItems) {
            if (!item.item.favorited) {
                anyUnfavorited = YES;
                break;
            }
        }
        self.favoriteItem.title = anyUnfavorited ? _NS("Add to Favorites") : _NS("Remove from Favorites");
        self.favoriteItem.action = anyUnfavorited ? @selector(addFavorite:) : @selector(removeFavorite:);
        [self.favoriteItem vlc_setActionImageWithSystemSymbolName:(anyUnfavorited ? @"heart" : @"heart.slash")];
        self.favoriteItem.hidden = isFavoritesSegment;
        
        // Update delete menu item title based on whether items are file-backed
        BOOL hasFileBacked = NO;
        BOOL hasNonFileBacked = NO;
        
        for (VLCLibraryRepresentedItem * const item in self.representedItems) {
            if (item.item.isFileBacked) {
                hasFileBacked = YES;
            } else {
                hasNonFileBacked = YES;
            }
            if (hasFileBacked && hasNonFileBacked) {
                break;
            }
        }
        
        if (hasFileBacked && hasNonFileBacked) {
            _deleteItem.title = _NS("Move to Trash / Delete from Library");
        } else if (hasFileBacked) {
            _deleteItem.title = _NS("Move to Trash");
        } else {
            _deleteItem.title = _NS("Delete from Library");
        }

    } else if (_representedInputItems != nil && self.representedInputItems.count > 0) {
        [self menuItems:_mediaItemRequiringMenuItems setHidden:YES];
        _removeFromPlaylistItem.hidden = YES;
        [self menuItems:_inputItemRequiringMenuItems setHidden:NO];
        self.favoriteItem.hidden = YES;

        BOOL anyStream = NO;
        for (VLCInputItem * const inputItem in self.representedInputItems) {
            if (inputItem.isStream) {
                anyStream = YES;
                break;
            }
        }

        const BOOL bookmarkable =
            self.representedInputItems.count == 1 &&
            self.representedInputItems.firstObject.inputType == ITEM_TYPE_DIRECTORY;

        [self menuItems:_localInputItemRequiringMenuItems setHidden:anyStream];
        [self menuItems:_folderInputItemRequiringMenuItems setHidden:!bookmarkable];
    }
}

- (BOOL)validateMenuItem:(NSMenuItem *)menuItem
{
    /* add media action is always available, every other action needs a represented item. */
    if (menuItem.action == @selector(addMedia:)) {
        return YES;
    }

    if (self.representedItems.count == 0 && self.representedInputItems.count == 0) {
        return NO;
    }

    if (menuItem == _informationItem) {
        for (VLCLibraryRepresentedItem * const item in self.representedItems) {
            if ([self representedItemHasInformationTarget:item]) {
                return YES;
            }
        }

        return NO;
    }

    if (menuItem == _revealItem && self.representedItems.count > 0) {
        return [self representedItemsCanBeRevealedInFinder];
    }

    return YES;
}

- (void)popupMenuWithEvent:(NSEvent *)theEvent forView:(NSView *)theView
{
    [NSMenu popUpContextMenu:_libraryMenu withEvent:theEvent forView:theView];
}

#pragma mark - actions

- (void)addInputItemToPlayQueue:(VLCInputItem*)inputItem
                playImmediately:(BOOL)playImmediately
{
    NSParameterAssert(inputItem);
    [VLCMain.sharedInstance.playQueueController addInputItem:inputItem.vlcInputItem
                                                 atPosition:-1
                                              startPlayback:playImmediately];
}

- (void)play:(id)sender
{
    if (self.representedItems != nil && self.representedItems.count > 0) {
        [self.representedItems.firstObject play];

        if (self.representedItems.count > 1) {
            for (NSUInteger i = 1; i < self.representedItems.count; i++) {
                [self.representedItems[i] queue];
            }
        }

    } else if (self.representedInputItems != nil && self.representedInputItems.count > 0) {
        [self addInputItemToPlayQueue:self.representedInputItems.firstObject
                      playImmediately:YES];

        if (self.representedInputItems.count > 1) {
            for (NSUInteger i = 1; i < self.representedInputItems.count; i++) {
                [self addInputItemToPlayQueue:self.representedInputItems[i]
                              playImmediately:NO];
            }
        }
    }
}

- (void)appendToPlayQueue:(id)sender
{
    if (self.representedItems != nil && self.representedItems.count > 0) {
        for (VLCLibraryRepresentedItem * const item in self.representedItems) {
            [item queue];
        }
    } else if (self.representedInputItems != nil && self.representedInputItems.count > 0) {
        for (VLCInputItem * const inputItem in self.representedInputItems) {
            [self addInputItemToPlayQueue:inputItem playImmediately:NO];
        }
    }
}

- (void)removeFromPlaylist:(id)sender
{
    if (self.representedItems.count == 0) {
        return;
    }

    VLCMediaLibraryPlaylist * const playlist =
        (VLCMediaLibraryPlaylist *)self.representedItems.firstObject.parentItem;
    if (![playlist isKindOfClass:VLCMediaLibraryPlaylist.class]) {
        return;
    }

    NSMutableArray<NSNumber *> * const positions =
        [NSMutableArray arrayWithCapacity:self.representedItems.count];
    for (VLCLibraryRepresentedItem * const repItem in self.representedItems) {
        if (repItem.positionInParent != NSNotFound) {
            [positions addObject:@(repItem.positionInParent)];
        }
    }

    [playlist removeMediaItemsAtPositions:positions];
}

- (void)renamePlaylist:(id)sender
{
    if (self.representedItems.count != 1) {
        return;
    }

    id<VLCMediaLibraryItemProtocol> const item = self.representedItems.firstObject.item;
    if (![item isKindOfClass:VLCMediaLibraryPlaylist.class]) {
        return;
    }

    VLCMediaLibraryPlaylist * const playlist = (VLCMediaLibraryPlaylist *)item;
    [VLCMain.sharedInstance.libraryController showRenamePlaylistDialogForPlaylist:playlist];
}

- (void)addMedia:(id)sender
{
    NSOpenPanel *openPanel = [NSOpenPanel openPanel];
    [openPanel setCanChooseFiles: NO];
    [openPanel setCanChooseDirectories: YES];
    [openPanel setAllowsMultipleSelection: YES];

    NSModalResponse modalResponse = [openPanel runModal];

    if (modalResponse == NSModalResponseOK) {
        VLCLibraryController *libraryController = VLCMain.sharedInstance.libraryController;
        for (NSURL *url in [openPanel URLs]) {
            [libraryController addFolderWithFileURL:url];
        }
    }
}

- (void)revealInFinder:(id)sender
{
    if (self.representedItems != nil && self.representedItems.count > 0) {
        [self.representedItems.firstObject revealInFinder];
    } else if (self.representedInputItems != nil && self.representedInputItems.count > 0) {
        [self.representedInputItems.firstObject revealInFinder];
    }
}

- (void)moveToTrash:(id)sender
{
    if (self.representedItems != nil && self.representedItems.count > 0) {
        for (VLCLibraryRepresentedItem * const item in self.representedItems) {
            [item moveToTrash];
        }
    } else if (self.representedInputItems != nil && self.representedInputItems.count > 0) {
        for (VLCInputItem * const inputItem in self.representedInputItems) {
            [inputItem moveToTrash];
        }
    }
}

- (void)showInformation:(id)sender
{
    if (!_informationWindowController) {
        _informationWindowController = [[VLCInformationWindowController alloc] init];
    }

    if (self.representedItems != nil && self.representedItems.count > 0) {
        [_informationWindowController setRepresentedMediaLibraryItems:self.representedItems];
    } else if (self.representedInputItems != nil && self.representedInputItems.count > 0) {
        _informationWindowController.representedInputItems = self.representedInputItems;
    }

    [_informationWindowController toggleWindow:sender];
}

- (void)addFavorite:(id)sender
{
    [self setItemsFavorite:YES];
}

- (void)removeFavorite:(id)sender
{
    [self setItemsFavorite:NO];
}

- (void)setItemsFavorite:(BOOL)favorite
{
    for (VLCLibraryRepresentedItem * const item in self.representedItems) {
        [item.item setFavorite:favorite];
    }
}

- (void)addToMediaLibrary:(id)sender
{
    if (self.representedInputItems == nil || self.representedInputItems.count == 0) {
        return;
    }
    
    VLCLibraryController * const libraryController = VLCMain.sharedInstance.libraryController;
    
    for (VLCInputItem * const inputItem in self.representedInputItems) {
        if (inputItem.inputType != ITEM_TYPE_DIRECTORY) {
            continue;
        }
        
        NSString * const inputItemMRL = inputItem.MRL;
        NSURL * const folderURL = [NSURL URLWithString:inputItemMRL];
        
        if (folderURL == nil) {
            msg_Warn(getIntf(), "Invalid URL for folder: %s", inputItemMRL.UTF8String);
            continue;
        }
        
        const int result = [libraryController addFolderWithFileURL:folderURL];
        if (result == VLC_SUCCESS) {
            msg_Info(getIntf(), "Added folder to media library: %s", inputItemMRL.UTF8String);
        } else {
            msg_Warn(getIntf(), "Failed to add folder to media library: %s (error %d)", inputItemMRL.UTF8String, result);
        }
    }
}

- (void)toggleBookmark:(id)sender
{
    if (self.representedInputItems == nil || 
        self.representedInputItems.count != 1 ||
        self.representedInputItems.firstObject.inputType != ITEM_TYPE_DIRECTORY) {
        return;
    }

    VLCInputItem * const inputItem = self.representedInputItems.firstObject;
    NSString * const inputItemMRL = inputItem.MRL;
    NSUserDefaults * const defaults = NSUserDefaults.standardUserDefaults;
    NSMutableArray<NSString *> * const bookmarkedLocations =
        [defaults stringArrayForKey:VLCLibraryBookmarkedLocationsKey].mutableCopy;
    NSNotificationCenter * const defaultCenter = NSNotificationCenter.defaultCenter;

    if ([bookmarkedLocations containsObject:inputItemMRL]) {
        [bookmarkedLocations removeObject:inputItemMRL];
    } else {
        [bookmarkedLocations addObject:inputItemMRL];
    }
    [defaults setObject:bookmarkedLocations forKey:VLCLibraryBookmarkedLocationsKey];
    [defaultCenter postNotificationName:VLCLibraryBookmarkedLocationsChanged object:inputItemMRL];
}

- (void)markUnseen:(id)sender
{
    vlc_medialibrary_t * const p_ml = vlc_ml_instance_get(getIntf());
    for (VLCLibraryRepresentedItem * const item in self.representedItems) {
        vlc_ml_media_set_played(p_ml, item.item.libraryID, false);
    }
}

- (void)setRepresentedItems:(NSArray<VLCLibraryRepresentedItem *> *)items
{
    _representedItems = items;
    _representedInputItems = nil;
    _addToPlaylistMenuController.representedItems = items;
    [self updateMenuItems];
}

- (void)setRepresentedInputItems:(NSArray<VLCInputItem *> *)representedInputItems
{
    _representedInputItems = representedInputItems;
    _representedItems = nil;
    _addToPlaylistMenuController.representedItems = nil;
    [self updateMenuItems];
}

@end