class Xcodeproj::XCScheme

def self.share_scheme(project_path, scheme_name, user = nil)
  to_folder = shared_data_dir(project_path)
  to_folder.mkpath
  to = to_folder + "#{scheme_name}.xcscheme"
  from = user_data_dir(project_path, user) + "#{scheme_name}.xcscheme"
  FileUtils.mv(from, to)
end

def self.shared_data_dir(project_path)
  project_path = Pathname.new(project_path)
  project_path + 'xcshareddata/xcschemes'
end

def self.user_data_dir(project_path, user = nil)
  project_path = Pathname.new(project_path)
  user ||= ENV['USER']
  project_path + "xcuserdata/#{user}.xcuserdatad/xcschemes"
end

def add_build_target(build_target, build_for_running = true)
  entry = BuildAction::Entry.new(build_target)
  entry.build_for_testing   = true
  entry.build_for_running   = build_for_running
  entry.build_for_profiling = build_for_running
  entry.build_for_archiving = build_for_running
  entry.build_for_analyzing = build_for_running
  build_action.add_entry(entry)
end

def add_test_target(test_target)
  testable = TestAction::TestableReference.new(test_target)
  test_action.add_testable(testable)
end

def analyze_action
  @analyze_action ||= AnalyzeAction.new(@scheme.elements['AnalyzeAction'])
end

def analyze_action=(action)
  @scheme.delete_element('AnalyzeAction')
  @scheme.add_element(action.xml_element)
  @analyze_action = action
end

def archive_action
  @archive_action ||= ArchiveAction.new(@scheme.elements['ArchiveAction'])
end

def archive_action=(action)
  @scheme.delete_element('ArchiveAction')
  @scheme.add_element(action.xml_element)
  @archive_action = action
end

def build_action
  @build_action ||= BuildAction.new(@scheme.elements['BuildAction'])
end

def build_action=(action)
  @scheme.delete_element('BuildAction')
  @scheme.add_element(action.xml_element)
  @build_action = action
end

def configure_with_targets(runnable_target, test_target, launch_target: false)
  if runnable_target
    add_build_target(runnable_target)
    set_launch_target(runnable_target) if launch_target
  end
  if test_target
    add_build_target(test_target, false) if test_target != runnable_target
    add_test_target(test_target)
  end
end

def initialize(file_path = nil)
  if file_path
    @file_path = file_path
    @doc = File.open(file_path, 'r') do |f|
      REXML::Document.new(f)
    end
    @doc.context[:attribute_quote] = :quote
    @scheme = @doc.elements['Scheme']
  else
    @doc = REXML::Document.new
    @doc.context[:attribute_quote] = :quote
    @doc << REXML::XMLDecl.new(REXML::XMLDecl::DEFAULT_VERSION, 'UTF-8')
    @scheme = @doc.add_element 'Scheme'
    @scheme.attributes['LastUpgradeVersion'] = Constants::LAST_UPGRADE_CHECK
    @scheme.attributes['version'] = Xcodeproj::Constants::XCSCHEME_FORMAT_VERSION
    self.build_action   = BuildAction.new
    self.test_action    = TestAction.new
    self.launch_action  = LaunchAction.new
    self.profile_action = ProfileAction.new
    self.analyze_action = AnalyzeAction.new
    self.archive_action = ArchiveAction.new
  end
end

def launch_action
  @launch_action ||= LaunchAction.new(@scheme.elements['LaunchAction'])
end

def launch_action=(action)
  @scheme.delete_element('LaunchAction')
  @scheme.add_element(action.xml_element)
  @launch_action = action
end

def profile_action
  @profile_action ||= ProfileAction.new(@scheme.elements['ProfileAction'])
end

def profile_action=(action)
  @scheme.delete_element('ProfileAction')
  @scheme.add_element(action.xml_element)
  @profile_action = action
end

def save!
  raise Informative, 'This XCScheme object was not initialized ' \
    'using a file path. Use save_as instead.' unless @file_path
  File.open(@file_path, 'w') do |f|
    f.write(to_s)
  end
end

def save_as(project_path, name, shared = true)
  scheme_folder_path = if shared
                         self.class.shared_data_dir(project_path)
                       else
                         self.class.user_data_dir(project_path)
                       end
  scheme_folder_path.mkpath
  scheme_path = scheme_folder_path + "#{name}.xcscheme"
  @file_path = scheme_path
  File.open(scheme_path, 'w') do |f|
    f.write(to_s)
  end
end

def set_launch_target(build_target)
  launch_runnable = BuildableProductRunnable.new(build_target, 0)
  launch_action.buildable_product_runnable = launch_runnable
  profile_runnable = BuildableProductRunnable.new(build_target)
  profile_action.buildable_product_runnable = profile_runnable
  macro_exp = MacroExpansion.new(build_target)
  test_action.add_macro_expansion(macro_exp)
end

def test_action
  @test_action ||= TestAction.new(@scheme.elements['TestAction'])
end

def test_action=(action)
  @scheme.delete_element('TestAction')
  @scheme.add_element(action.xml_element)
  @test_action = action
end

def to_s
  formatter = XMLFormatter.new(2)
  formatter.compact = false
  out = ''
  formatter.write(@doc, out)
  out.gsub!("<?xml version='1.0' encoding='UTF-8'?>", '<?xml version="1.0" encoding="UTF-8"?>')
  out << "\n"
  out
end