#!/usr/bin/env ruby

require 'calabash-android/version'
require 'calabash-android/operations'
require 'fileutils'
require 'json'
require 'uri'
require 'tmpdir'

def raise_if_android_home_not_set
  raise "Please set the ANDROID_HOME environment variable" unless ENV["ANDROID_HOME"]
end

def print_usage
  puts <<EOF
  Usage: testautoa <command-name> [parameters] [options]
  <command-name> can be one of
    setup
      Set up test automation configurations
    run
      Start test automation
    resign
      Resign the app with debug key
    build
      Build the test server
    gen
      Generate the skeleton of features directory
    createavd
      Create an Android Virtual Device
    runavd
      Start an Android Virtual Device
    devices
      List connected Android Devices
    install tools
      Install all tools
    getbuild list
      List available builds in the build drop
    getbuild <Version>
      Download the build with <Version>.
    getbuild trunk
      Download the trunk build
    getscript list
      List available scripts
    getscript <Script>
      Download the specified script
    go <Version> <Script>
      Download the build with <Version> and start test automation with <Script>
    version
      prints the gem version

  <options> can be
    -v, --verbose
      Turns on verbose logging
EOF
end

def is_windows?
    (RUBY_PLATFORM =~ /mswin|mingw|cygwin/)
end

def go
    version = ARGV.shift
    feature = ARGV.shift

    features_dir = File.join(FileUtils.pwd, "features")
    source_dir = File.join(File.dirname(__FILE__), '..', 'features-skeleton')
    testserver_dir = File.join(FileUtils.pwd, "test_servers")
    
    # delete feature directory
    FileUtils.rm_rf(features_dir)
    FileUtils.rm_rf(testserver_dir)
    
    FileUtils.cp_r(source_dir, features_dir)
    FileUtils.rm_rf(File.join(FileUtils.pwd, "features", "my_first.feature"))

    cmd = "testautoa getbuild #{version}"
    exit 1 if system(cmd) != true
    sleep(1)
    
    cmd = "testautoa getscript #{feature}"
    exit 1 if system(cmd) != true
    sleep(1)

    cmd = "testautoa resign"
    exit 1 if system(cmd) != true
    sleep(1)
    
    cmd = "testautoa build"
    exit 1 if system(cmd) != true
    sleep(1)
    
    cmd = "testautoa run"
    result = system(cmd)
    sleep(1)
end

def resign
    app_package = @settings["app_package"]
    STDOUT.sync = true
    cmd = "calabash-android resign #{app_package}"
    result = system(cmd)
    sleep(1)
    result
end

def build
    app_package = @settings["app_package"]
    STDOUT.sync = true
    cmd = "calabash-android build #{app_package}"
    result = system(cmd)
    sleep(1)
    result
end

def gen
    STDOUT.sync = true
    cmd = "calabash-android gen"
    result = system(cmd)
    sleep(1)
    result
end

def run(option)
    app_package = @settings["app_package"].to_s.strip
    test_server_port = @settings["test_server_port"].to_s.strip
    serial_number = @settings["device_serialno"].to_s.strip
    STDOUT.sync = true
    arguments = ARGV
    cmd = "calabash-android #{option} #{app_package} #{arguments.join(" ")}"
    env = {}
    if test_server_port != ''
        env["TEST_SERVER_PORT"] = test_server_port
    end
    if serial_number != ''
        env["ADB_DEVICE_ARG"] = serial_number
    end
    result = system(env, cmd)
    sleep(1)
    result
end

def setup
    read_settings
    puts "Settings for Test Automation"

    ask_for_setting("svn_location", "Please enter svn location for scripts", @settings["svn_location"])
    ask_for_setting("svn_location_tools", "Please enter svn location for tools", @settings["svn_location_tools"])
    ask_for_setting("svn_username", "Please enter svn username", @settings["svn_username"])
    ask_for_setting("svn_password", "Please enter svn password", @settings["svn_password"])

    ask_for_setting("build_drop_location", "Please enter build drop location", @settings["build_drop_location"])
    ask_for_setting("build_drop_username", "Please enter the username", @settings["build_drop_username"])
    ask_for_setting("build_drop_password", "Please enter the password", @settings["build_drop_password"])
  
    ask_for_setting("app_package", "Please enter the name of app package", @settings["app_package"])
    ask_for_setting("device_serialno", "Please enter the serial number of the device", @settings["device_serialno"])
    ask_for_setting("test_server_port", "Please enter the test server port", @settings["test_server_port"] ||= "34777")

    ask_for_setting("avd_name", "Please enter the name of Android emulator", @settings["avd_name"] ||= "testauto_avd")
    puts "Available Targets:"
    get_target_names.each{|i| puts "* #{i}" }
    ask_for_setting("avd_target", "Please enter the target of Android emulator", @settings["avd_target"] ||= "android-16")
    puts "Available CPUs:"
    get_abis(@settings["avd_target"]).each{|i| puts "* #{i}"}
    ask_for_setting("avd_cpu", "Please enter the CPU of Android emulator", @settings["avd_cpu"] ||= "armeabi-v7a")
    ask_for_setting("avd_sdcard_size", "Please enter the SD card size of Android emulator", @settings["avd_sdcard_size"] ||= "64M")
    ask_for_setting("avd_ram_size", "Please enter the RAM size of Android emulator", @settings["avd_ram_size"] ||= "1024")
    @settings["build_drop_branch_dir"] = "Mobile/Android/branch/Corp"
    @settings["build_drop_trunk_dir"] = "Mobile/Android/trunk/Corp"
  
    open('.testautoa_settings', 'w') do |f|
        f.puts @settings.to_json
    end
    puts "Saved your settings to .testautoa_settings. You can edit the settings manually or run this setup script again"
end

def ask_for_setting(key, msg, def_value)
    puts (def_value == "" ? msg : "#{msg} (#{def_value})")
    input = STDIN.gets.chomp
    if input.empty?
        @settings[key] = def_value
    elsif input.strip.empty?
        @settings[key] = ''
    else
        @settings[key] = input    
    end
end

def read_settings
    if File.exist? ".testautoa_settings"
        @settings = JSON.parse(IO.read(".testautoa_settings"))
    else
        @settings = {}
    end
end

def smb_connect_win(location,username,password)
    mount_node = location.tr('/', '\\')
    username = username.tr('/', '\\')

    cmd = "net use"
    output=`#{cmd}` ; result=$?.success?

    if output.include?(mount_node)
        cmd = "net use #{mount_node} /delete"
        output=`#{cmd}` ; result=$?.success?
    end

    cmd = "net use #{mount_node} #{password} /user:#{username}"
    output=`#{cmd}` ; result=$?.success?
    raise "the command '#{cmd}' failed" if result == false

    mount_node
end

def smb_disconnect_win(mount_node)
    cmd = "net use #{mount_node} /delete"
    output=`#{cmd}` ; result=$?.success?
end

def smb_connect_mac(location,username,password)
    # create mount node
    mount_node = "/Volumes/build_drop_temp"
    if File.exists?(mount_node)
        cmd = "umount #{mount_node}"
        output=`#{cmd}` ; result=$?.success?
        FileUtils.rm_rf(mount_node) if result == false
    end
    cmd = "mkdir #{mount_node}"
    output=`#{cmd}` ; result=$?.success?
    raise "the command '#{cmd}' failed" if result == false
    
    # mount smbfs
    location = location.tr('\\','/')
    username = username.tr('\\',';').tr('/',';')
    raise "The build drop location is incorrect" if not location.start_with?("//")
    paths = location.split('/')
    if paths.size > 4
        location = paths.shift(4).join('/')
        @settings["build_drop_branch_dir"] = [paths.join('/'), @settings["build_drop_branch_dir"]].join('/')
        @settings["build_drop_trunk_dir"] = [paths.join('/'), @settings["build_drop_trunk_dir"]].join('/')       
    end    
    cmd = "mount -t smbfs //'#{username}':#{password}@#{location[2..-1]}  #{mount_node}"
    output=`#{cmd}` ; result=$?.success?
    raise "the command '#{cmd}' failed" if result == false
    mount_node
end

def smb_disconnect_mac(mount_node)
    # unmount fs
    cmd = "umount -f #{mount_node}"
    output=`#{cmd}` ; result=$?.success?
    raise "the command '#{cmd}' failed" if result == false
end

def smb_connect(location,username,password)
    if is_windows?
        smb_connect_win(location,username,password)
    else
        smb_connect_mac(location,username,password)
    end
end

def smb_disconnect(mount_node)
    if is_windows?
        smb_disconnect_win(mount_node)
    else
        smb_disconnect_mac(mount_node)
    end    
end

def get_build
    raise "Please configure build drop location, username, and password first by running setup" if @settings["build_drop_location"].to_s.empty? or @settings["build_drop_username"].to_s.empty? or @settings["build_drop_password"].to_s.empty?
    
    mount_node = smb_connect(@settings["build_drop_location"], 
                             @settings["build_drop_username"], 
                             @settings["build_drop_password"])
    if ARGV.first == 'list'
        # list build versions
        branch_path = File.join(mount_node, @settings["build_drop_branch_dir"])
        Dir.entries(branch_path).sort_by{|c| File.stat(File.join(branch_path,c)).ctime}.each do |d|
            m = d.match(/^Android(\S+)$/)
            if m != nil
                puts m[1]
            end
        end
    else
        if ARGV.first == 'trunk'
            # copy the trunk build
            release_path = File.join(mount_node, @settings["build_drop_trunk_dir"])
        else
            # copy the version build
            release_path = File.join(mount_node, @settings["build_drop_branch_dir"], "Android#{ARGV.first}/Release")
        end
        raise "No builds found in #{release_path}" unless File.directory?(release_path)
        build_dir = Dir.entries(release_path).reject{|d|d.start_with?('.')}.sort_by{|c| File.stat(File.join(release_path,c)).ctime}.last 
        raise "No builds found in #{release_path}" if build_dir == nil
        apk_file = "ConcurMobile.apk"
        source = File.join(release_path, build_dir, apk_file)
        raise "the file '#{source}' does not exist" if not File.exists?(source)
        FileUtils.copy(source, File.join(FileUtils.pwd, apk_file))
        puts "Copy the build from #{source}"           
    end

    smb_disconnect(mount_node)
end

def get_script
    raise "Please configure Subversion location, username, and password first by running setup" if @settings["svn_location"].to_s.empty? or @settings["svn_username"].to_s.empty? or @settings["svn_password"].to_s.empty?
    
    username = @settings["svn_username"]
    password = @settings["svn_password"]
    uri = URI.join(@settings["svn_location"], "Mobile/", "BVT/", "CTE/")

    if ARGV.first == 'list'
        puts `svn list #{uri} --username #{username} --password #{password}`        
    else
        feature = ARGV.first + (ARGV.first.end_with?('/')? '' : '/')
        uri = URI.join(uri, feature)
        puts `svn export --force #{uri} features --username #{username} --password #{password}`

        uri = URI.join(@settings["svn_location"], "_support/", "support/")
        puts `svn export --force #{uri} features/support --username #{username} --password #{password}`
        uri = URI.join(@settings["svn_location"], "_support/", "step_definition/")
        puts `svn export --force #{uri} features/step_definitions --username #{username} --password #{password}`
    end
end

def adb_path
    raise_if_android_home_not_set
    File.join(ENV['ANDROID_HOME'], 'platform-tools', 'adb')
end

def adb_path_w_sn
    raise_if_android_home_not_set
    serial_number = @settings["device_serialno"].to_s.strip
    serial_number = " -s #{serial_number}" unless serial_number.empty?
    adb_path + serial_number
end

def adb_shell(command)
    system("#{adb_path_w_sn} shell #{command}")
end

def android_path
    raise_if_android_home_not_set
    File.join(ENV['ANDROID_HOME'], 'tools', 'android')
end

def emulator_path
    raise_if_android_home_not_set
    File.join(ENV['ANDROID_HOME'], 'tools', 'emulator')
end

def list_devices
    `#{adb_path} devices`.scan(/^(\S*)\s*device$/).each { |i| puts i[0] }
end

def get_target_names
    targets = `#{android_path} list target`.scan(/^id: (\d*) or "([^\"]*)"$/)
    targets.collect{|i| i[1]}
end

def get_abis(target)
    `#{android_path} list target`.scan(/^id: (\d+) or "#{target}"(?:(?:.*[\r\n]*)\s{5}.*)*ABIs : (.*)$/)[0][1].split(/[\s,]+/)
end

def list_target
    puts `#{android_path} list target`
end

def list_avd
    puts `#{android_path} list avd`
end

def create_avd
    android_targets = get_target_names.find_all{ |t| t =~ /android-(\d*)/ }
    google_targets = get_target_names.find_all{ |t| t =~ /Google Inc.:Google APIs:(\d*)/ }

    name = @settings["avd_name"]
    target = @settings["avd_target"]
    cpu = @settings["avd_cpu"]
    sdcard_size = @settings["avd_sdcard_size"]
    ram_size = @settings["avd_ram_size"]
    
    # validate settings
    raise "the target '#{target}' does not exist" if not get_target_names.include?(target)
    
    #create avd
    result = `echo no | \"#{android_path}\" create avd -f -n #{name} -t #{target} -c #{sdcard_size} -b #{cpu}`.include? "Created AVD '#{name}' based on Android"
    raise "Creating AVD Failed" if result == false
    config_ini = File.join(File.expand_path("~"), ".android", 'avd', "#{name}.avd", "config.ini")
    config_bak = File.join(File.expand_path("~"), ".android", 'avd', "#{name}.avd", "config.bak")
    File.open(config_ini, 'r') do |f_ini|
        File.open(config_bak, 'w') do |f_bak|
            while line = f_ini.gets
                match = line.match(/^hw.ramSize=(\d+)$/)
                f_bak.puts(match != nil ? "hw.ramSize=#{ram_size}" : line)
            end
        end
    end
    File.delete(config_ini)
    File.rename(config_bak, config_ini)
end

def run_avd
    avds = `#{android_path} list avd`.scan(/^\s*Name: (.*)$/).collect{|i| i[0]}
    avd_name = @settings["avd_name"]
    if avds.include?(avd_name)
        pid = spawn("#{emulator_path} -avd #{avd_name}")
    else
        puts "The AVD '#{avd_name}' does not exist"
    end
end

def install_tools
    raise "Please configure Subversion location for tools, username, and password first by running setup" if @settings["svn_location_tools"].to_s.empty? or @settings["svn_username"].to_s.empty? or @settings["svn_password"].to_s.empty?

    location = @settings["svn_location_tools"]
    location += '/' unless location.end_with?('/')    
    username = @settings["svn_username"]
    password = @settings["svn_password"]
    serial_number = @settings["device_serialno"].to_s.strip
    adb_dev_arg = ''
    adb_dev_arg = "-s #{serial_number}" unless serial_number.empty?
    
    # delete tools directory
    FileUtils.rm_rf(File.join(FileUtils.pwd, "tools"))

    system("svn export --force #{location} tools/ --username #{username} --password #{password}")
    tools = `svn list #{location} -R --username #{username} --password #{password}`.split(/\n/).select{|i| i.end_with?('.apk')}
    tools.each do |tool|
        tool_apk = File.join(FileUtils.pwd, "tools", tool)
        puts "Installing #{tool_apk}"
        system("#{adb_path} #{adb_dev_arg} install #{tool_apk}")
    end
end

if (ARGV.length == 0)
    print_usage
    exit 0
end

cmd = ARGV.shift

if cmd == 'help'
    print_usage
    exit 0

elsif cmd == 'setup'
    setup
    exit 0
    
elsif cmd == 'getbuild'
    read_settings
    File.open("#{Dir.tmpdir}/testauto.lock", 'w') { |f|
        f.flock(File::LOCK_EX)
        get_build
    }
    exit 0

elsif cmd == 'getscript'
    read_settings
    get_script
    exit 0

elsif cmd == 'devices'
    list_devices
    exit 0

elsif cmd == 'install'
    read_settings
    tools = ARGV.shift
    if tools == 'tools'
        install_tools
    end

elsif cmd == 'list'
    option = ARGV.shift
    if option == 'target'
        list_target
    elsif option == 'avd'
        list_avd
    end
    exit 0

elsif cmd == 'createavd'
    read_settings
    create_avd
    exit 0

elsif cmd == 'runavd'
    read_settings
    run_avd
    exit 0

elsif cmd == 'run' or cmd == 'console'
    read_settings
    run(cmd)
    
elsif cmd == 'resign'
    read_settings
    resign

elsif cmd == 'build'
    read_settings
    build

elsif cmd == 'gen'
    gen

elsif cmd == 'go'
    go
    
elsif cmd == 'version'
    puts Calabash::Android::VERSION
    exit 0

else
  print_usage
end