# encoding: utf-8
require 'fedux_org_stdlib/require_files'
require_library %w{ fileutils }

require 'fedux_org_stdlib/filesystem/exceptions'

# helper for file system
module FeduxOrgStdlib
  module Filesystem

    # The root directory of the project
    #
    # @return [String]
    #   the root directory
    def root_directory
      #::File.expand_path('../../../', __FILE__)
      raise Exceptions::InvalidUsageOfLibrary , "Sorry, but you need to define the root directory yourself"
    end

    # The temporary directory for the project
    #
    # @return [String]
    #   the directory created for the tests 
    def working_directory
      ::File.join(root_directory, 'tmp', 'test')
    end

    # Create temporary directory
    def create_working_directory
      FileUtils.mkdir_p(working_directory) unless ::File.exists? working_directory
    end

    # Delete temporary directory
    def delete_working_directory
      FileUtils.rm_rf(working_directory) if ::File.exists? working_directory
    end

    # Clean up test directory
    def cleanup_working_directory
      delete_working_directory
      create_working_directory
    end

    # Switch the current working directory to 
    # the temporary one and execute code block
    def switch_to_working_directory(&block)
      Dir.chdir(working_directory, &block)
    end
    alias_method :in_working_directory, :switch_to_working_directory

    # Create directory(ies)
    #
    # @param [String,Array] dirs
    #   the directories to be created, multiple arguments are possible as well
    #
    # @return [String,Array] 
    #   returns a string if there was only one file given, and an array with 
    #   muliple files
    def create_directory(*dirs)
      raise_if_forbidden_path_for_create_operation(dirs)

      directories = expand_path(dirs.flatten)
      FileUtils.mkdir_p(directories)

      if directories.size == 1
        return directories.first
      else
        return directories
      end
    end

    # Delete directory(ies)
    #
    # @param [String, Array] dirs
    #   the directories to be deleted, multiple arguments are possible as well
    #
    # @return [String,Array] 
    #   returns a string if there was only one file given, and an array with 
    #   muliple files
    def delete_directory(*dirs)
      raise_if_forbidden_path_for_delete_operation(dirs)

      directories = expand_path(dirs.flatten)
      FileUtils.rm_r(directories)

      if directories.size == 1
        return directories.first
      else
        return directories
      end
    end

    # Check existence of path(s)
    #
    # @param [String,Array] paths
    #   which path(s) should be checked, multiple arguments are possible as well
    #
    # @return [TrueClass,FalseClass]
    #   the result of all checks done
    def path_exists?(*paths)
      raise_if_forbidden_path_for_create_operation(paths)

      paths_expanded = expand_path(paths.flatten)
      paths_expanded.flatten.all? { |p| ::File.exists?(p) }
    end

    # Check absence of path(s)
    #
    # @param [String,Array] paths
    #   which path(s) should be checked, multiple arguments are possible as well
    #
    # @return [TrueClass,FalseClass]
    #   the result of all checks done
    def path_does_not_exist?(*paths)
      not path_exists?(paths)
    end

    # Create a single file
    #
    # @param [String] path
    #   the path for the new file (can include directories)
    #
    # @param [String] content
    #   the content written to the file
    #
    # @return [String]
    #   the path to the created file
    def create_file(path, content='', mode=0644)
      raise_if_forbidden_path_for_create_operation(path)

      file = expand_path(path).first
      directory = ::File.dirname(file)

      FileUtils.mkdir_p(directory) unless directory == '.'
      ::File.open(file, "wb") do |f|
        f.write content
      end

      FileUtils.chmod(mode, file)

      file
    end

    # Delete a single file
    #
    # @param [String] files
    #   the path for the new file (can include directories)
    #
    # @return [String]
    #   the path to the deleted file
    def delete_file(*files)
      raise_if_forbidden_path_for_delete_operation(files)

      files_to_be_deleted = expand_path(files.flatten)
      FileUtils.rm(files_to_be_deleted)

      if files_to_be_deleted.size == 1
        return files_to_be_deleted.first
      else
        return files_to_be_deleted
      end
    end

    # Read the content of a file
    #
    # @param [String] path
    #   the path to the file
    #
    # @return [String,Binary] 
    #   the content of the file
    def read_file(path)
      raise_if_forbidden_path_for_create_operation(path)

      file_path = expand_path(path).first
      return ::File.read(file_path)
    end

    # Expand path based on temporary directory
    #
    # @param [String, Array, Multiple Values] paths
    #   the paths to be expanded
    #
    # @return [Array, String]
    #   the expanded arrays
    def expand_path(*paths)
      raise_if_forbidden_path_for_create_operation(paths)

      paths.flatten.map do |p| 
        case p 
        when /^~/
          ::File.expand_path(p) 
        else
          ::File.join(working_directory, p ) 
        end
      end
    end

    # Check if path is forbidden for delete operation
    # 
    # @param [String, Array] paths
    #   paths which should be checked
    #
    # @return [TrueClass, FalseClass]
    #   true if path is forbidden, false if path is not forbidden
    def raise_if_forbidden_path_for_create_operation(*paths)
      flattend_paths = paths.flatten
      strings = []
      regex = %r[\.\.]

      raise FileSystem::Exceptions::InvalidPath , "Sorry, but you cannot use paths matching \"#{strings.join(', ')}\"  or \"#{regex.inspect}\" here!" if path_matches?(strings, regex, flattend_paths)
    end

    # Check if path is forbidden for delete operation
    #
    # @param [String, Array] paths
    #   paths which should be checked
    #
    # @return [TrueClass, FalseClass]
    #   true if path is forbidden, false if path is not forbidden
    def raise_if_forbidden_path_for_delete_operation(*paths)
      flattend_paths = paths.flatten
      strings = %w[ / ]
      regex = %r[\.\.]

      raise FileSystem::Exceptions::InvalidPath , "Sorry, but you cannot use paths matching \"#{strings.join(', ')}\"  or \"#{regex.to_s}\" here!" if path_matches?(strings, regex, flattend_paths)
    end

    # Check if path matches
    #
    # @param [Array, String] strings
    #   strings which are checked against paths
    #
    # @param [Array, String] regex
    #   regex which is checked against path
    #
    # @param [Array, String] paths
    #   the paths to be checked
    #
    # @return [TrueClass, FalseClass] 
    #   true if path is valid, false if invalid
    def path_matches?(strings, regex, *paths)
      flattend_paths = paths.flatten
      flattend_strings = strings.flatten

      flattend_paths.any? { |f|  f =~ regex or flattend_strings.include?(f) }
    end
  end
end