└───Videos
    │   Heat.1995.1080p.BRrip.x264.YIFY.mp4
    │   heat.png
    │   leon.png
    │   Leon.the.Professional.Extended.1994.BrRip.x264.YIFY.mp4
    │   mononoke hime.png
    │   Mononoke.hime.[Princess.Mononoke].[DUAL.AUDIO]1997.HDTVRip.x264.YIFY.mkv
    │   Oblivion.2013.1080p.BluRay.x264.YIFY.mp4
    │   oblivion.png
    │   terminator 2.png
    │   Terminator.2.Judgment.Day.1991.DC.1080p.BRrip.x264.GAZ.YIFY.mp4
    │   traffic.png
    │
    └───Series
            S01E01.Some.Show.mp4
            S01E02.Some.Show.mp4
            S01E03.Some.Show.mp4

     Videos
  1  Heat.1995.1080p.BRrip.x264.YIFY
  2  Leon.the.Professional.Extended.1994.BrRip.x264.YIFY
  3  Mononoke.hime.[Princess.Mononoke].[DUAL.AUDIO]1997.HDTVRip.x264.YIFY
  4  Oblivion.2013.1080p.BluRay.x264.YIFY
  5  Terminator.2.Judgment.Day.1991.DC.1080p.BRrip.x264.GAZ.YIFY

     Series
  6  S01E01.Some.Show
  7  S01E02.Some.Show
  8  S01E03.Some.Show

module Main where

import Control.Monad (forM)
import Data.Char (toLower)
import Data.List (isInfixOf, nub, sort, sortBy)
import Data.List.Split (splitOn)
import System.Directory (doesDirectoryExist, listDirectory)
import System.FilePath (takeBaseName, takeDirectory, takeExtension, ())
import Text.Printf (printf)


videoDirectory = "C:\\Users\\Swonkie\\Downloads\\Videos"
videoExtensions = [".mp4", ".mkv", ".avi", ".m4v"]

-- ANSI / VT color codes
color = "\ESC[1;31m"
reset = "\ESC[m"

type Library = [Directory]

data Directory = Directory { name  :: String
                           , files :: [Video]
                           }
instance Show Directory where
    show (Directory name files) = "     " ++ color ++ name ++ reset ++ "\n" ++ (unlines $ map show files)

data Video = Video { index  :: Integer
                   , path   :: FilePath
                   }
instance Show Video where
    show (Video i path) = printf "%3d  %s" i (takeBaseName path)


isVideoFile :: FilePath -> Bool
isVideoFile path = takeExtension path `elem` videoExtensions

-- | not used yet
getVideoByIndex :: [Video] -> Integer -> Maybe Video
getVideoByIndex files i =
    if length v > 0
        then Just (head v)
        else Nothing
    where v = filter (\ v -> index v == i) files

-- | not used yet
getVideoByName :: [Video] -> String -> Maybe Video
getVideoByName files s =
    if length v > 0
        then Just (head v)
        else Nothing
    where v = filter (\ v -> isInfixOf (map toLower s) (map toLower $ takeBaseName $ path v)) files


-- | The name of the folder containing the file, without its parent folders.
bottomFolder :: FilePath -> String
bottomFolder path = last $ splitOn "\\" $ takeDirectory path

-- | A list of all unique directory names which appear in the list of videos.
getDirectories :: [Video] -> [String]
getDirectories videos = nub $ map (bottomFolder . path) videos

-- | Filters the list of videos down to only those which are in a specific directory.
getVideosInDirectory :: [Video] -> String -> [Video]
getVideosInDirectory videos name = filter (\ v -> (bottomFolder $ path v) == name) videos

-- | Bundles the videos in a specific directory in a Directory type.
getDirectory :: [Video] -> String -> Directory
getDirectory videos name = Directory name (getVideosInDirectory videos name)

-- | Creates Video objects with indexes
getVideos :: [FilePath] -> [Video]
getVideos list = [Video (fst tp) (snd tp) | tp <- zip [1..] list]

-- | Gets all the directories of the videos and creates a list of Directory types.
getLibrary :: [Video] -> Library
getLibrary videos = map (getDirectory videos) $ getDirectories videos

getRecursiveContents :: FilePath -> IO [FilePath]
getRecursiveContents topdir = do
    names <- listDirectory topdir
    paths <- forM names $ \ name -> do
        let path = topdir  name
        isDirectory <- doesDirectoryExist path
        if isDirectory
            then getRecursiveContents path
            else return [path]
    return (concat paths)

main :: IO ()
main = do
    -- get all video files recursively
    files <- getRecursiveContents videoDirectory    
    let videoFiles = sort $ filter isVideoFile files

    -- adding a character to the end of the path is a hack, to have subdirs sorted below parent dirs
    -- apparently "end of string" is last in the sort order, not first (weird)
    let sortedByDirectory = sortBy (\ a b -> compare (takeDirectory a ++ "$") (takeDirectory b ++ "$")) videoFiles
    let lib = getLibrary $ getVideos sortedByDirectory

    -- show the list of videos
    putStrLn ""
    putStr $ unlines $ map show lib