#pragma region CPL License
/*
Nuclex Native Framework
Copyright (C) 2002-2013 Nuclex Development Labs

This library is free software; you can redistribute it and/or
modify it under the terms of the IBM Common Public License as
published by the IBM Corporation; either version 1.0 of the
License, or (at your option) any later version.

This library 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
IBM Common Public License for more details.

You should have received a copy of the IBM Common Public
License along with this library
*/
#pragma endregion // CPL License

#ifndef NUCLEX_STORAGE_FILESYSTEM_GENERIC_GENERICWINDOWSFILE_H
#define NUCLEX_STORAGE_FILESYSTEM_GENERIC_GENERICWINDOWSFILE_H

#include "Nuclex/Storage/Config.h"

#if defined(NUCLEX_STORAGE_WIN32) || defined(NUCLEX_STORAGE_WINRT)

#include "Nuclex/Storage/FileSystem/File.h"
#include "../../Helpers/WindowsApi.h"
#include "../../Helpers/DateHelper.h"

#include <string>
#include <mutex>

namespace Nuclex { namespace Storage { namespace FileSystem {

  // ------------------------------------------------------------------------------------------- //

  /// <summary>File on a Windows system using either Win32 or WinRT</summary>
  /// <typeparam name="TFileApi">
  ///   A class wrapping the API-specific file system methods
  /// </typeparam>
  /// <typeparam name="TPathHelper">
  ///   A class containing helper methods for working with paths on the platform
  /// </typeparam>
  /// <remarks>
  ///   The differences between Win32 and WinRT are minor as far as file handling
  ///   is concerned, so both share this class to perform their file acccesses,
  ///   using the FileApi and PathHelper to handle the API differences.
  /// </remarks>
  template<typename TFileApi, typename TPathHelper>
  class GenericWindowsFile : public File {

    /// <summary>Accesses a file on windows</summary>
    /// <param name="path">Path of the file that will be opened or created</param>
    public: GenericWindowsFile(const std::string &path) :
      path(path),
      name(TPathHelper::GetLastPathElement(path)),
      fileHandle(INVALID_HANDLE_VALUE),
      lastLocation(0),
      isOpenedWritable(false) {}

    /// <summary>Frees all resources owned by the instance</summary>
    public: virtual ~GenericWindowsFile() {
      if(this->fileHandle != INVALID_HANDLE_VALUE) {
        TFileApi::CloseFile(this->fileHandle);
      }
    }

    /// <summary>Determines the size of the file</summary>
    /// <returns>The size of the file in bytes</returns>
    public: std::uint64_t GetSize() const {
      std::lock_guard<std::mutex> scope(this->mutex); {
        if(this->fileHandle == INVALID_HANDLE_VALUE) {
          WIN32_FILE_ATTRIBUTE_DATA fileAttributeData;
          if(TFileApi::GetFileAttributesEx(this->path, fileAttributeData)) {
            return
              (static_cast<std::uint64_t>(fileAttributeData.nFileSizeHigh) << 32) |
              fileAttributeData.nFileSizeLow;
          } else {
            return 0; // File doesn't exist yet - not an error!
          }
        } else { // File was already opened
          return TFileApi::GetFileSize(this->fileHandle);
        }
      } // mutex
    }

    /// <summary>Returns the name of the file</summary>
    /// <returns>The file's name</returns>
    public: const std::string &GetName() const { return this->name; }

    /// <summary>Changes the name of the file</summary>
    /// <param name="name">New name the file will be known under</param>
    public: void SetName(const std::string &name) {
      std::lock_guard<std::mutex> scope(this->mutex); {
        if(this->fileHandle != INVALID_HANDLE_VALUE) {
          close();
        }

        std::string newPath = TPathHelper::CombinePaths(
          TPathHelper::RemoveLastElement(this->path), name
        );

        TFileApi::MoveFile(this->path, newPath);
        
        this->name = name;
        this->path = newPath;
      }
    }

    /// <summary>Returns the path the file is stored at in the native format</summary>
    /// <returns>The file's absolute path in the native OS format</returns>
    public: const std::string &GetNativePath() const { return this->path; }

    /// <summary>Retrieves the time at which the file has been last modified</summary>
    /// <returns>The since since the last modification of the file took place</returns>
    public: std::time_t GetLastModificationTime() const {
      using Nuclex::Storage::Helpers::DateHelper;

      std::lock_guard<std::mutex> scope(this->mutex); {
        if(this->fileHandle == INVALID_HANDLE_VALUE) {
          WIN32_FILE_ATTRIBUTE_DATA fileAttributeData;
          if(TFileApi::GetFileAttributesEx(this->path, fileAttributeData)) {
            return DateHelper::PosixTimeFromFileTime(
              fileAttributeData.ftLastWriteTime.dwHighDateTime,
              fileAttributeData.ftLastWriteTime.dwLowDateTime
            );
          } else {
            return 0; // File doesn't exist yet - not an error!
          }
        } else { // File was already opened
          return DateHelper::PosixTimeFromFileTime(
            TFileApi::GetLastModificationTime(this->fileHandle)
          );
        }
      } // mutex
    }

    /// <summary>Reads raw data from the file</summary>
    /// <param name="location">Absolute file position data will be read from</param>
    /// <param name="buffer">Buffer into which data will be read</param>
    /// <param name="count">Number of bytes that will be read</param>
    public: void ReadAt(
      std::uint64_t location, void *buffer, std::size_t count
    ) const {
      std::lock_guard<std::mutex> scope(this->mutex); {

        // Make sure the file is opened so that we can read from it
        if(this->fileHandle == INVALID_HANDLE_VALUE) {
          this->fileHandle = TFileApi::OpenFileForReading(this->path);
        }

        // If the file pointer is not where we need it to be, move it
        if(location != this->lastLocation) {
          moveFilePointer(location);
        }

        // Perform the actual read through the Windows API
        std::size_t actualCount = TFileApi::Read(this->fileHandle, buffer, count);

        // Whether the read was cut off at the end of the file or not, the file pointer will
        // still have been moved and we need to account for this.
        this->lastLocation += actualCount;
        if(actualCount != count) {
          throw std::out_of_range("Attempted to read beyond the end of the file");
        }

      } // mutex
    }

    /// <summary>Writes raw data into the file</summary>
    /// <param name="location">Absolute file position data will be written to</param>
    /// <param name="buffer">Buffer from which data will be taken</param>
    /// <param name="count">Number of bytes that will be written</param>
    public: void WriteAt(
      std::uint64_t location, const void *buffer, std::size_t count
    ) {
      std::lock_guard<std::mutex> scope(this->mutex); {

        // If the file is still closed or has been opened in the wrong mode,
        // make sure that it is opened in the right mode for the write.
        if(this->fileHandle == INVALID_HANDLE_VALUE) {
          this->fileHandle = TFileApi::OpenFileForWriting(this->path);
        } else if(!this->isOpenedWritable) {
          close();
          this->fileHandle = TFileApi::OpenFileForWriting(this->path);
        }

        // If the file pointer is not where we need it to be, move it
        if(location != this->lastLocation) {
          moveFilePointer(location);
        }

        // Perform the actual write through the Windows API
        std::size_t actualCount = TFileApi::Write(this->fileHandle, buffer, count);

        // Whether the write was aborted early or not, as long as the method returned success,
        // the file pointer will still have moved, so we need to account for this.
        this->lastLocation += actualCount;
        if(actualCount != count) {
          throw std::out_of_range("Write was aborted early");
        }

      } // mutex
    }

    /// <summary>Ensures changes to the file have been written to disk</summary>
    public: void Flush() {
      std::lock_guard<std::mutex> scope(this->mutex); {
        if(this->fileHandle != INVALID_HANDLE_VALUE) {
          TFileApi::FlushFileBuffers(this->fileHandle);
        }
      }
    }

    /// <summary>Closes the file</summary>
    private: void close() {
      if(this->fileHandle != INVALID_HANDLE_VALUE) {
        TFileApi::CloseFile(this->fileHandle);
        this->fileHandle = INVALID_HANDLE_VALUE;
        this->lastLocation = 0;
      }
    }

    /// <summary>Moves the file pointer to the specified location<summary>
    /// <param name="location">Location the file pointer will be moved to</param>
    /// <remarks>
    ///   Having a const method that promises a state changing operation might seem icky.
    ///   Here's the reason this exists: the File class abstracts away the entire concept
    ///   of file cursors. Thus, as far as the user is concerned, there is no current
    ///   location and a const file instance can be read from without second thought.
    ///   The Win32 file API however relies very much on file cursors.
    /// </remarks>
    private: void moveFilePointer(std::uint64_t location) const {
      std::uint64_t actualLocation = TFileApi::SetFilePointer(this->fileHandle, location);

      this->lastLocation = actualLocation;
      if(actualLocation != location) {
        throw std::out_of_range("Invalid file offset");
      }
    }

    /// <summary>Handle of the opened file for Windows' file functions</summary>
    private: mutable HANDLE fileHandle;
    /// <summary>Synchronize file accesses from multiple threads</summary>
    /// <remarks> 
    ///   This is required because the Windows file implementation still forces
    ///   a file cursor upon us. Opening multiple file handles would only inrease
    ///   complexity when the underlying hardware cannot do parallel reads anyway.
    /// </remarks>
    private: mutable std::mutex mutex;
    /// <summary>Location of the last read or write</summary>
    private: mutable std::uint64_t lastLocation;
    /// <summary>Whether the file is currently opened for writing</summary>
    private: mutable bool isOpenedWritable;
    /// <summary>Absolute path of the file</summary>
    private: std::string path;
    /// <summary>The file's name</summary>
    private: std::string name;

  };

  // ------------------------------------------------------------------------------------------- //

}}} // namespace Nuclex::Storage::FileSystem

#endif // defined(NUCLEX_STORAGE_WIN32) || defined(NUCLEX_STORAGE_WINRT)
#endif // NUCLEX_STORAGE_FILESYSTEM_GENERIC_GENERICWINDOWSFILE_H