// -----------------------------------------------------------------------
// <copyright file="FileState.cs" company="GRNet">
// Copyright 2011 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>
// -----------------------------------------------------------------------

using System.Diagnostics.Contracts;
using System.IO;
using System.Threading.Tasks;
using Castle.ActiveRecord;
using Castle.ActiveRecord.Framework;
using Pithos.Core.Agents;
using Pithos.Interfaces;
using log4net;

namespace Pithos.Core
{
    using System;
    using System.Collections.Generic;
    using System.Linq;

    /// <summary>
    /// TODO: Update summary.
    /// </summary>
    [ActiveRecord]
    public class FileState:ActiveRecordLinqBase<FileState>
    {
        private static readonly ILog Log = LogManager.GetLogger("FileState");
        
        private string _filePath;
        private IList<FileTag> _tags=new List<FileTag>();

        [PrimaryKey(PrimaryKeyType.Guid)]
        public Guid Id { get; set; }

        [Property(Unique=true,UniqueKey="IX_FileState_FilePath")]
        public string FilePath
        {
            get { return _filePath; }
            set { _filePath = value.ToLower(); }
        }

        [Property]
        public FileOverlayStatus OverlayStatus { get; set; }

        [Property]
        public FileStatus FileStatus { get; set; }

        [Property]
        public string Checksum { get; set; }


        [Property]
        public long? Version { get; set; }

        [Property]
        public DateTime? VersionTimeStamp { get; set; }


        [Property]
        public bool IsShared { get; set; }

        [Property]
        public string SharedBy { get; set; }

        [Property]
        public bool ShareWrite { get; set; }


       [HasMany(Cascade = ManyRelationCascadeEnum.AllDeleteOrphan, Lazy = true,Inverse=true)]
        public IList<FileTag> Tags
        {
            get { return _tags; }   
            set { _tags=value;}
        }

   
        public static FileState FindByFilePath(string absolutePath)
        {
            if (string.IsNullOrWhiteSpace(absolutePath))
                throw new ArgumentNullException("absolutePath");
            Contract.EndContractBlock();
            try
            {
                return Queryable.FirstOrDefault(s => s.FilePath == absolutePath.ToLower());
            }
            catch (Exception ex)
            {
                Log.Error(ex.ToString());
                throw;
            }
                

        }

        public static void DeleteByFilePath(string absolutePath)
        {
            if(string.IsNullOrWhiteSpace(absolutePath))
                throw new ArgumentNullException("absolutePath");
            Contract.EndContractBlock();
            
            Execute((session, instance) =>
                             {
                                 const string hqlDelete = "delete FileState where FilePath = :path";                                 
                                 var deletedEntities = session.CreateQuery(hqlDelete)
                                         .SetString("path", absolutePath.ToLower())
                                         .ExecuteUpdate();
                                 return deletedEntities;
                             },null);
            
        }

        public static void StoreFileStatus(string absolutePath, FileStatus newStatus)
        {
            if (string.IsNullOrWhiteSpace(absolutePath))
                throw new ArgumentNullException("absolutePath");
            Contract.EndContractBlock();

            Execute((session, instance) =>
            {
                const string hqlUpdate = "update FileState set FileStatus= :status where FilePath = :path  ";
                var updatedEntities = session.CreateQuery(hqlUpdate)
                        .SetString("path", absolutePath.ToLower())
                        .SetEnum("status", newStatus)
                        .ExecuteUpdate();
                if (updatedEntities == 0)
                {
                    var newState = new FileState { FilePath = absolutePath.ToLower(), Id = Guid.NewGuid(), FileStatus = newStatus };
                    newState.CreateAndFlush();
                }
                return null;
            }, null);

        }

        public static void StoreOverlayStatus(string absolutePath, FileOverlayStatus newStatus)
        {
            if (string.IsNullOrWhiteSpace(absolutePath))
                throw new ArgumentNullException("absolutePath");
            Contract.EndContractBlock();

            Execute((session, instance) =>
            {
                const string hqlUpdate = "update FileState set OverlayStatus= :status where FilePath = :path  ";
                var updatedEntities = session.CreateQuery(hqlUpdate)
                        .SetString("path", absolutePath.ToLower())
                        .SetEnum("status", newStatus)
                        .ExecuteUpdate();
                if (updatedEntities == 0)
                {
                    var newState = new FileState { FilePath = absolutePath, Id = Guid.NewGuid(), OverlayStatus = newStatus };
                    newState.CreateAndFlush();
                }
                return null;
            }, null);

        }

        public static void UpdateStatus(string absolutePath, FileStatus fileStatus, FileOverlayStatus overlayStatus)
        {
            if (string.IsNullOrWhiteSpace(absolutePath))
                throw new ArgumentNullException("absolutePath");
            Contract.EndContractBlock();

            Execute((session, instance) =>
            {
                const string hqlUpdate = "update FileState set OverlayStatus= :overlayStatus, FileStatus= :fileStatus where FilePath = :path  ";
                var updatedEntities = session.CreateQuery(hqlUpdate)
                        .SetString("path", absolutePath.ToLower())
                        .SetEnum("fileStatus", fileStatus)
                        .SetEnum("overlayStatus", overlayStatus)
                        .ExecuteUpdate();
                return updatedEntities;
            }, null);

        }
        public static void UpdateStatus(string absolutePath, FileStatus fileStatus)
        {
            if (string.IsNullOrWhiteSpace(absolutePath))
                throw new ArgumentNullException("absolutePath");
            Contract.EndContractBlock();

            Execute((session, instance) =>
            {
                const string hqlUpdate = "update FileState set FileStatus= :fileStatus where FilePath = :path  ";
                var updatedEntities = session.CreateQuery(hqlUpdate)
                        .SetString("path", absolutePath.ToLower())
                        .SetEnum("fileStatus", fileStatus)                        
                        .ExecuteUpdate();
                return updatedEntities;
            }, null);

        }

        public static void RenameState(string oldPath, string newPath)
        {
            if (string.IsNullOrWhiteSpace(oldPath))
                throw new ArgumentNullException("oldPath");
            Contract.EndContractBlock();

            Execute((session, instance) =>
            {
                const string hqlUpdate = "update FileState set FilePath= :newPath where FilePath = :oldPath  ";
                var updatedEntities = session.CreateQuery(hqlUpdate)
                        .SetString("oldPath", oldPath.ToLower())
                        .SetString("newPath", newPath.ToLower())                                          
                        .ExecuteUpdate();
                return updatedEntities;
            }, null);

        }

        public static void UpdateStatus(Guid id, FileStatus fileStatus)
        {
            Contract.EndContractBlock();

            Execute((session, instance) =>
            {
                const string hqlUpdate = "update FileState set FileStatus= :fileStatus where Id = :id  ";
                var updatedEntities = session.CreateQuery(hqlUpdate)
                        .SetGuid("id", id)
                        .SetEnum("fileStatus", fileStatus)                        
                        .ExecuteUpdate();
                return updatedEntities;
            }, null);

        }

        public static void UpdateChecksum(string absolutePath, string checksum)
        {
            if (string.IsNullOrWhiteSpace(absolutePath))
                throw new ArgumentNullException("absolutePath");
            Contract.EndContractBlock();

            Execute((session, instance) =>
            {
                const string hqlUpdate = "update FileState set Checksum= :checksum where FilePath = :path  ";
                var updatedEntities = session.CreateQuery(hqlUpdate)
                        .SetString("path", absolutePath.ToLower())
                        .SetString("checksum", checksum)                        
                        .ExecuteUpdate();
                return updatedEntities;
            }, null);

        }

        public static void ChangeRootPath(string oldPath,string newPath)
        {
            if (String.IsNullOrWhiteSpace(oldPath))
                throw new ArgumentNullException("oldPath");
            if (!Path.IsPathRooted(oldPath))
                throw new ArgumentException("oldPath must be an absolute path", "oldPath");
            if (string.IsNullOrWhiteSpace(newPath))
                throw new ArgumentNullException("newPath");
            if (!Path.IsPathRooted(newPath))
                throw new ArgumentException("newPath must be an absolute path", "newPath");
            Contract.EndContractBlock();

            //Ensure the paths end with the same character
            if (!oldPath.EndsWith("\\"))
                oldPath = oldPath + "\\";
            if (!newPath.EndsWith("\\"))
                newPath = newPath + "\\";

            using (new TransactionScope())
            {
                Execute((session, instance) =>
                            {
                                const string hqlUpdate =
                                    "update FileState set FilePath = replace(FilePath,:oldPath,:newPath) where FilePath like :oldPath || '%' ";
                                var renames=session.CreateQuery(hqlUpdate)
                                    .SetString("oldPath", oldPath.ToLower())
                                    .SetString("newPath", newPath.ToLower())
                                    .ExecuteUpdate();
                                return renames;
                            }, null);
            }
        }

        public static Task<FileState> CreateForAsync(string filePath,int blockSize,string algorithm)
        {
            if (blockSize <= 0)
                throw new ArgumentOutOfRangeException("blockSize");
            if (String.IsNullOrWhiteSpace(algorithm))
                throw new ArgumentNullException("algorithm");
            Contract.EndContractBlock();


            var fileState = new FileState
                                {
                                    FilePath = filePath.ToLower(), 
                                    OverlayStatus = FileOverlayStatus.Unversioned, 
                                    FileStatus = FileStatus.Created,
                                    Id=Guid.NewGuid()
                                };


            return fileState.UpdateHashesAsync(blockSize,algorithm);            
        }

        public async Task<FileState> UpdateHashesAsync(int blockSize,string algorithm)
        {
            if (blockSize<=0)
                throw new ArgumentOutOfRangeException("blockSize");
            if (String.IsNullOrWhiteSpace(algorithm))
                throw new ArgumentNullException("algorithm");
            Contract.EndContractBlock();
            
            //Skip updating the hash for folders
            if (Directory.Exists(FilePath))
                return this;

            var hash = await TaskEx.Run(() =>
            {
                var info = new FileInfo(FilePath);
                return info.CalculateHash(blockSize, algorithm);
            });

            Checksum = hash;
            
            return this;
        }
    }

    [ActiveRecord("Tags")]
    public class FileTag : ActiveRecordLinqBase<FileTag>
    {
        [PrimaryKey]
        public int Id { get; set; }

        [Property]
        public string Name { get; set; }

        [Property]
        public string Value { get; set; }

        [BelongsTo("FileStateId")]
        public FileState FileState { get; set; }

    }
   
}