require 'helix_web_services_client'
require 'helix_versioning_engine/util'

module HelixVersioningEngine
  # Used to obtain consistent output to "files" commands and return output in
  # our model format for consumption by other services.
  class FileService

    attr_reader :p4

    def initialize(p4: nil)
      @p4 = p4
    end

    def list(dirs)
      if dirs.nil? || dirs.empty?
        list_depots
      else
        list_dir(dirs)
      end
    end

    def list_depots
      results = p4.run_depots
      normalize_depots(results)
      results.map{ |r| HelixWebServicesClient::Models::Depot.new(r) }
    end

    def list_file(file_path)
      files_results = nil
      p4.at_exception_level(P4::RAISE_NONE) do
        files_results = p4.run_files(file_path)
      end

      normalize_files(files_results)
      results = files_results[0]

      return nil unless results

      print_results = p4.run_print(file_path)

      results['Content'] = Base64.encode64(print_results[1])

      HelixWebServicesClient::Models::File.new(results)
    end

    def list_dir(dirs)
      file_selector = '//' + dirs.join('/')
      files_results = nil
      p4.at_exception_level(P4::RAISE_NONE) do
        files_results = p4.run_files(file_selector)
      end
      files_results = [] unless files_results

      return_val = nil

      if files_results.length == 1 &&
          files_results.first.key?('depotFile') &&
          files_results.first['depotFile'] == file_selector
        # Treat request like a single file GET
        normalize_files(files_results)
        results = files_results[0]

        print_results = p4.run_print(file_selector)

        results['Content'] = Base64.encode64(print_results[1])

        return_val = HelixWebServicesClient::Models::File.new(results)
      else

        # Treat request like a directory list
        selector = '//' + dirs.join('/') + '/*'

        files_results = p4.run_files('-e', selector)
        normalize_files(files_results)

        items = files_results.map { |f| HelixWebServicesClient::Models::File.new(f) }

        dirs_results = p4.run_dirs(selector)
        normalize_dirs(dirs_results)

        dirs = dirs_results.map { |d| HelixWebServicesClient::Models::Dir.new(d) }

        items.concat(dirs)

        return_val = items
      end

      return_val
    end

    def normalize_depots(results)
      @normalize_depots ||= Util.normalizer('depots', offset)
      @normalize_depots.call(results)
    end

    def normalize_files(results)
      @normalize_files ||= Util.normalizer('files', offset)
      @normalize_files.call(results)
    end

    def normalize_dirs(results)
      @normalize_dirs ||= Util.normalizer('dirs', offset)
      @normalize_dirs.call(results)
    end

    def offset
      @offset ||= fetch_offset
    end

    def fetch_offset
      results = p4.run_info
      Util.p4_date_offset(results[0]['serverDate'])
    end
  end
end