require 'rake/clean'
require 'rake/packagetask'
require 'bundler'

task :set_writable do
  Dir.glob('**/Gemfile.lock').each do |f|
    File.chmod(0644, f)
  end
end

Rake::PackageTask.new('helix-web-services', :noversion) do |package|
  package.need_tar = true

  package.package_files.include('contrib/**/*')
  package.package_files.include('doc/**/*')
  package.package_files.include('git_fusion_strings/**/*')
  package.package_files.include('helix_web_services/**/*')
  package.package_files.include('helix_web_services_client/**/*')
  package.package_files.include('packaging/**/*')
  package.package_files.include('Gemfile')
  package.package_files.include('Gemfile.lock')
  package.package_files.include('Rakefile')
  package.package_files.include('LICENSE')
end
CLEAN.include('pkg')

task :package => [:set_writable]

desc 'Rebuild the main ASCIIDoc documentation'
task :asciidoc do
  system('bundle exec asciidoctor -o doc-output/p4ws.html doc/p4ws.asc') ||
      fail('asciidoctor failed')
end
CLEAN.include('**/doc-output')

namespace :all do
  desc 'Rebuild documentation across system'
  task :doc => [:asciidoc] do
    system('cd helix_web_services_client && bundle exec rake yard') ||
        fail('rake yard failed for helix_web_services_client')
    system('cd helix_web_services && bundle exec rake yard') ||
        fail('rake yard failed for helix_web_services')
  end
end

desc 'Run the local and cloud tests'
task :test do
  Rake::Task['test:local'].invoke
  Rake::Task['test:cloud'].invoke
end

namespace :test do
  desc 'Run unit and integrated tests against a local development server'
  task :local do
    error = run_local_tests

    fail('tests failed, see output for details') if error
  end

  desc 'Run unit and integrated tests against a cloud development server'
  task :cloud do
    error = run_cloud_tests

    fail('tests failed, see output for details') if error
  end

  CLEAN.include('**/spec-output')
end

desc 'Run integrated client tests against a remote server'
task :remotetest, [:host] do |task, args|
  error ||= run_remote_client_tests(args[:host])

  fail('tests failed, see output for details') if error
end

namespace 'init' do
  desc 'initialize p4d'
  task :p4d do
    initialize_p4d('data/p4init')
  end

  namespace 'p4d' do
    desc 'initialize cloud p4d'
    task :cloud do
      initialize_p4d('data/cloudinit')
    end
  end
end

desc 'kill mock cloud server' 
task :kill_mock_server do
  stop_mock_raymond
end

def run_local_tests
  error = initialize_p4d('data/p4init')
  error ||= initialize_development_unicorn

  error ||= run_server_tests
  error ||= run_client_tests(local:true)

  cleanup

  return error
end

def run_cloud_tests
  error = initialize_p4d('data/cloudinit')
  error ||= start_mock_raymond

  # TODO: just generate a default config file for CI?
  error ||= initialize_development_unicorn(cloud_settings:'config/hws_cloud_settings.conf.example')

  error ||= run_server_tests(cloud_settings:'config/hws_cloud_settings.conf.example')
  error ||= run_client_tests(local:false)

  stop_mock_raymond
  cleanup

  return error
end

def initialize_p4d(data_dir)
  puts 'starting p4d from ' + data_dir

  ok = system('p4util kill')
  return true unless ok

  if Dir.exist?('/tmp/p4util/p4droot')
    require 'fileutils'
    FileUtils.rmtree('/tmp/p4util/p4droot')
  end

  ok = system('p4util start')
  return true unless ok

  ok = system("p4util init #{data_dir}")
  return true unless ok
end

def start_mock_raymond(cloud_settings:'')
  # return
  puts 'starting mock_raymond'
  begin
    Bundler.with_clean_env do
      ok = system(
          'cd helix_web_services/mock_raymond && ' +
              'UNICORN_PID=/tmp/mock_raymond_unicorn.pid ' +
              'RAILS_ENV=test ' +
              'MOCKRAYMOND_STDOUT_PATH=/tmp/mock_raymond_unicorn.out ' +
              'MOCKRAYMOND_STDERR_PATH=/tmp/mock_raymond_unicorn.err ' +
              'P4PORT=localhost:1666 ' + 
              'P4CHARSET=utf8 ' + 
              'bundle exec unicorn -c config/unicorn.rb -D'
      )
      return true unless ok

      while connect_to_server(3000) == false
        sleep(0.1)
      end
    end

    return false
  rescue Exception => e
    puts "Error: #{e.message}"
    return true
  end
end

def stop_mock_raymond
  if File.exist?('/tmp/mock_raymond_unicorn.pid')
    rails_pid = IO.read('/tmp/mock_raymond_unicorn.pid').to_i
    puts "killing pid: #{rails_pid}"
    Process.kill('TERM', rails_pid)
    File.unlink('/tmp/mock_raymond_unicorn.pid')
  end
end

def initialize_remote_p4d(host)
  ok = system("p4util init -p #{host}:1666 -a #{data_dir}.pkg")
  return true unless ok
end

def initialize_development_unicorn(cloud_settings:'')
  puts "starting unicorn"
  begin
    Bundler.with_clean_env do
      ok = system(
        'cd helix_web_services && ' +
            'WORKSPACE_DIR=/tmp/tokens ' +
            'UNICORN_PID=/tmp/unicorn.pid ' +
            'CLOUD_SETTINGS="' + cloud_settings + '" ' +
            'HWS_STDOUT_PATH=/tmp/unicorn.out ' +
            'HWS_STDERR_PATH=/tmp/unicorn.err ' +
            'bundle exec unicorn -c config/unicorn.rb -D'
      )
      return true unless ok

      while connect_to_server(9000) == false
        sleep(0.1)
      end
    end

    return false
  rescue Exception => e
    puts "Error: #{e.message}"
    return true
  end
end

def connect_to_server(port)
  require 'socket'
  begin
    s = TCPSocket.new 'localhost', port
    s.close
    return true
  rescue Exception => e
    return false
  end
end

def run_server_tests(cloud_settings:'')
  ok = system('cd helix_web_services && CLOUD_SETTINGS="' + cloud_settings + 
    '" SPEC_OUT="' + (cloud_settings.empty? ? '../spec-output/helix_web_services_specs.html' : '../spec-output/helix_web_services_cloud_specs.html') + 
    '" bundle exec rake spec')
  return true unless ok
end

def run_client_tests(local:true)
  ok = system('cd helix_web_services_client && ' + 
    'CLOUD_TEST=' + (!local).to_s + ' ' +
    'SPEC_OUT=' + (local ? '../spec-output/helix_web_services_client_specs.html' : '../spec-output/helix_web_services_client_cloud_specs.html') + ' ' +
    'bundle exec rake spec')
  return true unless ok
end

def run_remote_client_tests(host)
  ok = system("cd helix_web_services_client && P4PORT=#{host}:1666 WS_URL=https://#{host}/hws bundle exec rake spec")
  return true unless ok
end

def cleanup
  ok = system('p4util kill')
  return true unless ok

  if Dir.exist?('/tmp/p4util/p4droot')
      require 'fileutils'
      FileUtils.rmtree('/tmp/p4util/p4droot')
  end

  if File.exist?('/tmp/unicorn.pid')
    unicorn_pid = IO.read('/tmp/unicorn.pid').to_i
    puts "killing pid: #{unicorn_pid}"
    Process.kill('TERM', unicorn_pid)
    File.unlink('/tmp/unicorn.pid')
  end
end

desc 'Create primary source deliverables'
task :build => [:package]