# -*- ruby -*-
# sake variant sake0

require 'sake0/component'

class Sake::CompBuild
  def pyd_file
    generated_file("_ctypes.pyd")
  end
end

$comp = Sake::Component.new(:basename => 'ctypes',
                            :vendor => "HIIT",
                            :version => [0, 2],
                            :uid_v9 => 0xe3462354, # test UID for v9
                            :caps => Sake::DEV_CERT_CAPS)

if $sake_op[:kits]
  $kits = Sake::DevKits::get_exact_set($sake_op[:kits].strip.split(/,/))
else
  # Target all devices that look like they support Python builds.
  $kits = Sake::DevKits::get_all
  $kits.delete_if do |kit|
    !kit.supports_python?
  end
end

$signsisrc = File.join(ENV["HOME"], "symbian-signed", "signsis.rb")
load($signsisrc) if File.exist? $signsisrc

if $sake_op[:szeged]
  # use Szeged GCC 3.0 backport
  $epoc_gcc = "gcc-3.0-psion-98r2"
end

$builds = $kits.map do |kit|
  Sake::CompBuild.new :component => $comp, :devkit => kit
end
$builds = $builds.map do |build|
  if build.target.symbian_platform.major_version >= 9
    selfbuild = build.to_self_signed
    selfbuild.cert_file = $sake_op[:cert] || $self_cert || raise
    selfbuild.key_file = $sake_op[:key] || $key_file || raise
    selfbuild.passphrase = $sake_op[:passphrase] || $key_password

    devbuild = build.to_dev_signed
    devbuild.cert_file = $sake_op[:cert] || $dev_cert || raise
    devbuild.key_file = $sake_op[:key] || $key_file || raise
    devbuild.passphrase = $sake_op[:passphrase] || $key_password

    [selfbuild, devbuild]
  end
end
$builds.compact!
$builds.flatten!

# We probably do not require separate documentation for every single
# build variant, as at least the interface should be just about the
# same in each file; although given that we are documenting private
# stuff, too, there could be differences, but still, let us just pick
# one version.
$doc_build = $builds.last

for build in $builds
  map = build.trait_map

  if $sake_op[:logging] and map[:has_flogger]
    map[:do_logging] = :define
  end

  # The new thing here is that we are using Open C.
  # So its libc.lib, and not estlib.lib.
  list = %w{libc.lib libdl.lib libm.lib euser.lib libffi.lib python222.lib}
  build.libs = list

  list = %w{_ctypes.c stgdict.c callbacks.c callproc.c cfield.c ffitypes_impl.c}
  list = list.sort.map do |x|
    $comp.src_dir + x
  end
  build.cxx_files = list
end

task :default => [:pyd, :sis]

require 'sake0/tasks'

Sake::Tasks::def_list_devices_tasks(:builds => $builds)

Sake::Tasks::def_makefile_tasks(:builds => $builds, :open_c => true)

Sake::Tasks::def_pyd_tasks(:builds => $builds)

Sake::Tasks::def_sis_tasks(:builds => $builds)

Sake::Tasks::def_clean_tasks(:builds => $builds)

task :all => [:makefiles, :pyd]

if $doc_build
  # C++ API documentation.
  Sake::Tasks::def_doxygen_tasks(:build => $doc_build)
  task :all => :cxxdoc

  # Python API documentation.
  py_file = $doc_build.src_dir + ($doc_build.component.basename + ".py")
  Sake::Tasks::def_pydoc_tasks(:build => $doc_build, :py_file => py_file)
  task :all => :pydoc
end

Sake::Tasks::def_dist_tasks :builds => $builds

Sake::Tasks::force_uncurrent_on_op_change

task :web do
  srcfiles = Dir['web/*.txt2tags.txt']
  for srcfile in srcfiles
    htmlfile = srcfile.sub(/\.txt2tags\.txt$/, ".html")
    sh("tools/txt2tags --target xhtml --infile %s --outfile %s --encoding utf-8 --verbose" % [srcfile, htmlfile])
  end
end

task :upload do
  ruby("local/upload.rb")
end

task :upload_dry do
  ruby("local/upload.rb", "dry")
end

def sis_info opt
  for build in $builds
    if build.short_sisx_file.exist?
      sh("sisinfo -f #{build.short_sisx_file} #{opt}")
    end
  end
end

task :sis_ls do
  sis_info "-i"
end

task :sis_cert do
  sis_info "-c"
end

task :sis_struct do
  sis_info "-s"
end