{- | Third assignment for IB016, semester spring 2017, 20 points (+bonus).

== Implementing du

In this assignment you will implement a simplified version of unix
utility @du@. This utility can be used to detect filesystem usage by
files and directories. You should create a standalone executable  module.
This time, only the outer specification in given, you have to do the
functional decomposition yourself.

=== du usage / commandline options (20 points)

Your program usage should be:

@
./du [options] [files-or-directories]
@

You should implement following options:

@
-a, --all             write counts for all files, not just directories
    --si              like -h, but use powers of 1000 not 1024 (e.g., 1KB, 245MB, 2.1GB)
-h, --human-readable  print sizes in human readable format (e.g., 1KiB 234MiB 2GiB)
-s, --summarize       display only a total for each argument
-c, --total           produce a grand total
    --help            display help and exit
@

You don't need to handle invalid options, you can ignore them.

=== du behaviour

Then @du@ is run without any options, it prints sizes of all its commandline
arguments: for files the size is printed directly, for directories their
size is summarized recursively. By default, files inside directories are 
not printed. If any options are given, they precede all files and
directories (you can take that for granted and don't have to check).
If no files or directories are given, @du@ should work with
current working directory (./).

By default, sizes are printed in kibibytes without the unit 
(1 KiB = 1024 B).
With --human-readable (or -h) sizes are printed with an appropriate
unit (using binary prefixes <https://en.wikipedia.org/wiki/Binary_prefix>)
such that the value is between 1 and 1023. If --si is given, sizes
are handled similarly but using 1000-based SI prefixes (and value
should be between 1 and 999). If the value is less then 10, one decimal place 
is displayed, otherwise there are no decimals (though rounding can be arbitrary).

All the other command line options should be handled according to usage given
above. If --help is given, a short help summarizing options and usage should
be displayed and all other options should be ignored.


=== Bonus (+5 points)

Optionally, as a bonus, you can also implement:

@
-d, --max-depth       print  the  total  for  a directory (or file, with --all)
                      only if it is N or fewer levels below the command line
                      argument;  --max-depth=0 is the same as --summarize
@

In this case, you can assume that option and its value is not separated by space
— for short version number follows immediately, while in long option it
is separated by @'='@: @-d0 -d10 --max-depth=0 --max-depth=10@.

Combination of @-s@ and @-a@ is not valid, and need not be handled, the same
holds for --max-depth=0 and --all.

==== Further notes

*   In basic execution (without @-s@), subdirectories are printed.
*   In case of error (such as permission error or directory vanishing before
    it can be explored) program should not stop but print an error message
    (on 'stderr'), you should handle only 'IOException' and you can use
    that it is an instance of 'Show'.
*   You can ignore anything that is neither file, nor directory (such
    as devices, symlinks, pipes,…).
*   You should not ignore hidden files (on unix beginning with '.').
*   The original linux @du@ is calculating file sizes based on disk allocation,
    sizes reported by 'hFileSize' can differ (that is OK).
*   You can assume no files or directories are named as valid options
    (e.g. there is no file named '--all').

== Module and package constraints

You can use any modules from any packages, but all used packaged (except base)
have to be noted in the header of this file next to your name and UID.

To get the list of used packages on linux conveniently, you can use the following 
command (copy from the source code, not from the generated HTML).

@
ghc <your-file>.hs -n -hide-all-packages 2>&1 | grep package | sed 's/^[^‘]*‘\([^’@]*\).*/\1/' | sort | uniq
@

=== Tips and tricks

*   For the recursive traversal, functions from @System.Directory@ may be handy.
*   File size can be obtained by calling 'hFileSize' from @System.IO@ or
    alternatively by 'fileSize' from @System.Posix.Files@. However, the latter 
    case is not multiplatform).
*   You can use @Text.Printf@ for formating.
*   Think twice before you start writing the code. Doing a proper functional
    decomposition will save you a lot of work/refactoring. Think of the
    functions you'll need, write their type signatures and only then
    start programming.
*   You may use monoids for command line arguments processing, but you
    don't have to.
*   There are many useful general-purpose packages on Hackage, see for example the
    <https://hackage.haskell.org/package/MissingH/ MissingH> package.
    If there is something reasnably common you want, try to search Hackage first
    (but do not install everything just for a small function).

==== Examples

Order of files and directories on same level in hierarchy is not relevant and can
differ on your system. Also the output in case of error need not match literally.

> $ ./du --help
> usage: du [options] [files]
>   -a, --all             write counts for all files, not just directories
>       --si              like -h, but use powers of 1000 not 1024
>   -h, --human-readable  print sizes in human readable format (e.g., 1K 234M 2G)
>   -s, --summarize       display only a total for each argument
>   -d, --max-depth       print  the  total  for  a directory (or file, with --all) only if it is N or fewer levels below the command line argument;  --max-depth=0 is the same as --summarize
>   -c, --total           produce a grand total
>       --help            display this help and exit
>
> $ mkdir test; cd test
> $ mkdir -p first/second third
> $ dd if=/dev/zero of=a bs=1024 count=100 &> /dev/null
> $ dd if=/dev/zero of=first/b bs=1024 count=200 &> /dev/null
> $ dd if=/dev/zero of=first/c bs=1024 count=300 &> /dev/null
> $ dd if=/dev/zero of=first/second/d bs=1024 count=1024 &> /dev/null
>
> $ ../du
> 0  ./third
> 1024   ./first/second
> 1524   ./first
> 1624   .
>
> $ ../du first third
> 1024   first/second
> 1524   first
> 0  third
>
> $ ../du -c first third
> 1024   first/second
> 1524   first
> 0      third
> 1524   total
>
> $ ../du first
> 1024      first/second
> 1524      first
>
> $ ../du -s first
> 1524    first
>
> $ ../du --summarize first
> 1524    first
>
> $ ../du -h first
> 1.0 MiB   first/second
> 1.4 MiB   first
>
> $ ../du --si first
> 1.1 MB    first/second
> 1.5 MB    first
>
> $ ./du -h -s -c first a
> 1.4 MiB   first
> 100 KiB   a
> 1.5 MiB   total
>
> $ ./du -a -h first
> 200 KiB   first/b
> 300 KiB   first/c
> 1.0 MiB   first/second/d
> 1.0 MiB   first/second
> 1.4 MiB   first
>
> $ mkdir fourth && chmod -r fourth
> $ ../du fourth first
> error: fourth: getDirectoryContents: permission denied (Permission denied)
> 1024   first/second
> 1524   first/
>
> $ ./du fifth first
> error: fifth: openFile: does not exist (No such file or directory)
> 1024   first/second
> 1524   first
>
> $ ../du -d1
> error: ./fourth: getDirectoryContents: permission denied (Permission denied)
> 0  ./third
> 1524   ./first
> 1624   .
>
> $ ../du --max-depth=1 --human-readable
> error: ./fourth: getDirectoryContents: permission denied (Permission denied)
> 0.0 B  ./third
> 1.4 MiB  ./first
> 1.5 MiB
-}

-- Name: Name Surname
-- UID: 123456
-- Used packages: base

module Main ( main ) where

main :: IO ()
main = undefined