#region
/* -----------------------------------------------------------------------
 * <copyright file="FileInfoExtensions.cs" company="GRNet">
 * 
 * Copyright 2011-2012 GRNET S.A. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met:
 *
 *   1. Redistributions of source code must retain the above
 *      copyright notice, this list of conditions and the following
 *      disclaimer.
 *
 *   2. Redistributions in binary form must reproduce the above
 *      copyright notice, this list of conditions and the following
 *      disclaimer in the documentation and/or other materials
 *      provided with the distribution.
 *
 *
 * THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 * The views and conclusions contained in the software and
 * documentation are those of the authors and should not be
 * interpreted as representing official policies, either expressed
 * or implied, of GRNET S.A.
 * </copyright>
 * -----------------------------------------------------------------------
 */
#endregion
using System;
using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Linq;
using System.Text;
using System.IO;
using System.Text.RegularExpressions;
using System.Threading.Tasks;


namespace Pithos.Interfaces
{
    public static class FileInfoExtensions
    {
        public static  string AsRelativeTo(this FileSystemInfo fileInfo,string path )
        {
            if (String.IsNullOrWhiteSpace(path))
                throw new ArgumentNullException("path");            
            Contract.EndContractBlock();
            Contract.Assume(Enum.IsDefined(typeof(StringComparison),StringComparison.InvariantCultureIgnoreCase));

            if (!path.EndsWith("\\"))
                path=path.ToLower() + "\\";
            int pathLength = path.Length;            
            
            var filePath = fileInfo.GetProperCapitalization();
            
            if (!filePath.StartsWith(path,StringComparison.InvariantCultureIgnoreCase))
                throw new ArgumentException(String.Format("The path {0} doesn't contain the file {1}",path,filePath));
            
            var relativePath = filePath.Substring(pathLength, filePath.Length - pathLength);

            return relativePath;
        }

        public static string AsRelativeUrlTo(this FileSystemInfo fileInfo,string path )
        {
            if (String.IsNullOrWhiteSpace(path))
                throw new ArgumentNullException("path");
            Contract.EndContractBlock();

            var relativePath = fileInfo.AsRelativeTo(path);
            var replacedSlashes = relativePath.Replace("\\","/");
            var escaped = Uri.EscapeUriString(replacedSlashes);
            return escaped;
        }

        public static string RelativeUriToFilePath(this Uri uri)
        {
            var unescaped = Uri.UnescapeDataString(uri.ToString());
            var path = unescaped.Replace("/", "\\");
            return path;
        }


        public static string GetProperDirectoryCapitalization(string fileName)
        {
            Contract.Ensures(!String.IsNullOrWhiteSpace(Contract.Result<string>()));
            Contract.EndContractBlock();
            
            if (String.IsNullOrWhiteSpace(fileName))
                return String.Empty;

            var dirInfo = new DirectoryInfo(fileName);
            return dirInfo.GetProperCapitalization();
        }


        public static string GetProperCapitalization(this DirectoryInfo dirInfo)
        {
            if (dirInfo == null)
                throw new ArgumentNullException("dirInfo");
            Contract.EndContractBlock();
            Contract.Assume(!String.IsNullOrWhiteSpace(dirInfo.FullName));

            var parentDirInfo = dirInfo.Parent;
            if (null == parentDirInfo)
                return dirInfo.Name;

            try
            {


                if (dirInfo.Exists)
                    return Path.Combine(GetProperDirectoryCapitalization(parentDirInfo.FullName),
                                        parentDirInfo.GetDirectories(dirInfo.Name)[0].Name);
                else
                {
                    return dirInfo.FullName;
                }
            }
            catch (DirectoryNotFoundException)
            {
                //An exception can occur if a directory is deleted right after the Exists call
                return dirInfo.FullName;
            }
        }


        public static string GetProperFilePathCapitalization(string fileName)
        {
            Contract.Ensures(!String.IsNullOrWhiteSpace(Contract.Result<string>()));
            Contract.EndContractBlock();
            if (String.IsNullOrWhiteSpace(fileName))
                return String.Empty;


            var fileInfo = new FileInfo(fileName);
            return fileInfo.GetProperCapitalization();
        }

        public static string GetProperCapitalization(this FileInfo fileInfo)
        {
            if (fileInfo == null)
                throw new ArgumentNullException("fileInfo");
            Contract.EndContractBlock();


            var dirInfo = fileInfo.Directory;

            //Directory will not be null for an absolute path
            Contract.Assume(dirInfo != null);

            try
            {
                //Exists returns a cached value that can be true even if a file was deleted since the
                //FileInfo object was created.
                fileInfo.Refresh();
                if (fileInfo.Exists)
                    return Path.Combine(GetProperDirectoryCapitalization(dirInfo.FullName),
                                        dirInfo.GetFiles(fileInfo.Name)[0].Name);
                else
                {
                    return fileInfo.FullName;
                }
            }
            catch (FileNotFoundException)
            {
                //An exception can occur if a file is deleted right after the Exists call
                return fileInfo.FullName;

            }
        }

        public static string GetProperCapitalization(this FileSystemInfo info)
        {
            if (info is FileInfo)
                return (info as FileInfo).GetProperCapitalization();
            if (info is DirectoryInfo)
                return (info as DirectoryInfo).GetProperCapitalization();
            throw new NotSupportedException("Unexpected parameter type");
        }

        public static DirectoryInfo WithProperCapitalization(this DirectoryInfo dirInfo)
        {
            if (dirInfo==null)
                throw new ArgumentNullException("dirInfo");
            Contract.EndContractBlock();

            var path = dirInfo.GetProperCapitalization();
            return new DirectoryInfo(path);
        }

        public static FileInfo WithProperCapitalization(this FileInfo fileInfo)
        {
            if (fileInfo==null)
                throw new ArgumentNullException("fileInfo");
            Contract.EndContractBlock();

            var path = fileInfo.GetProperCapitalization();
            return new FileInfo(path);
        }

        public static FileSystemInfo WithProperCapitalization(this FileSystemInfo info)
        {
            if (info==null)
                throw new ArgumentNullException("info");
            Contract.EndContractBlock();

            if (info is FileInfo)
                return (info as FileInfo).WithProperCapitalization();
            if (info is DirectoryInfo)
                return (info as DirectoryInfo).WithProperCapitalization();

            throw new NotSupportedException("Unexpected parameter type");
        }

        public static FileSystemInfo FromPath(string filePath)
        {
            if (String.IsNullOrWhiteSpace(filePath))
                throw new ArgumentNullException("filePath");
            Contract.EndContractBlock();

            return Directory.Exists(filePath) ? 
                (FileSystemInfo) new DirectoryInfo(filePath) 
                : new FileInfo(filePath);
        }
    }
}