#!/usr/bin/env ruby
# frozen_string_literal: true

require 'fileutils'
require 'securerandom'
require 'digest/sha2'
require 'pathname'
require 'opal'
require 'parser'
require 'uglifier'
require 'rubygems'
require 'gems'

# utils

def modify_and_copy_file(source_path, destination_path, destination_dir)

  file_content = File.read(source_path)
  cleaned_content = file_content.encode('UTF-8', 'binary', invalid: :replace, undef: :replace, replace: '')
  modified_code = cleaned_content.gsub(/require\s+(['"])(.*?)\1/) do |match|
    quote = $1
    relative_path = $2
    if relative_path.start_with?('./')
      relative_path_copy = "#{relative_path}"
      relative_path_copy.slice!(0, 2)
      destination_dir_copy = "#{destination_dir}"
      destination_dir_copy.slice!(0, 2)
      "require #{quote}#{relative_path_copy}#{quote}"
    else
      match
    end

  end
  File.write(destination_path, modified_code)
end

def process_directories(source_dir, destination_dir)

  Dir.entries(source_dir).each do |entry|
    next if entry == '.' || entry == '..'

    source_path = File.join(source_dir, entry)
    destination_path = File.join(destination_dir, entry)

    if File.directory?(source_path)
      Dir.mkdir(destination_path) unless Dir.exist?(destination_path)
      process_directories(source_path, destination_path)
    elsif File.file?(source_path)
      modify_and_copy_file(source_path, destination_path, destination_dir)
    end
  end
end

# builders
def build_aui(destination, project_name)
  path = "#{destination}/#{project_name}/src/utilities/"
  FileUtils.mkdir_p(path) unless Dir.exist?(path)
  uuid = SecureRandom.uuid
  sha = Digest::SHA256.hexdigest(uuid)
  coded_id = sha.gsub('-', '_')
  aui_file = <<~STR
    class Atome
      def self.aui
        "#{coded_id}"
      end
    end
  STR
  File.new("#{path}aui.rb", 'w')
  File.open("#{path}aui.rb", 'w') do |f|
    f.puts aui_file
  end
  # now building opal version
  js_directory = "#{destination}/#{project_name}/src/js"
  opal_js = "#{js_directory}/aui.js"
  FileUtils.mkdir_p(js_directory)
  File.new opal_js, 'w'
  # we add platform_specific script to the Opal framework
  opal_content = Opal::Builder.build("#{path}aui.rb").to_s
  File.open(opal_js, 'w') do |f|
    f.puts opal_content
  end

end

def build_host_mode(destination, project_name, mode)
  path = "#{destination}/#{project_name}/src/utilities/"
  FileUtils.mkdir_p(path) unless Dir.exist?(path)
  host_type = <<~STR
    class Atome
      def self.host
        "#{mode}"
      end
    end
  STR
  File.new("#{path}host_mode.rb", 'w')
  File.open("#{path}host_mode.rb", 'w') do |f|
    f.puts host_type
  end
  # now building opal version
  js_directory = "#{destination}/#{project_name}/src/js"
  opal_js = "#{js_directory}/host_mode.js"
  File.new opal_js, 'w'
  # we add platform_specific script to the Opal framework
  opal_content = Opal::Builder.build("#{path}host_mode.rb").to_s
  File.open(opal_js, 'w') do |f|
    f.puts opal_content
  end
end

# opal compilation
def build_opal_application(_source, destination, project_name)
  # first we need to remplace all './require ' with require  so opal can parse the path
  Dir.mkdir("#{destination}/#{project_name}/tmp") unless Dir.exist?("#{destination}/#{project_name}/tmp")
  unless Dir.exist?("#{destination}/#{project_name}/tmp/application")
    Dir.mkdir("#{destination}/#{project_name}/tmp/application")
  end
  process_directories("#{destination}/#{project_name}/application", "#{destination}/#{project_name}/tmp/application")

  opal_compiler_content = <<STR
# frozen_string_literal: true

require 'opal'
application_js = "../../src/js/application.js"
builder = Opal::Builder.new
builder.append_paths("./")
application_content = builder.build("./index.rb").to_s
File.open(application_js, 'w') do |f|
  f.puts application_content
end
STR

  # we create an hidden file
  opal_compiler = "#{destination}/#{project_name}/tmp/application/.opal_compiler.rb"
  File.open(opal_compiler, 'w') do |f|
    f.puts opal_compiler_content
  end
  if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
    # code to exec with Windows
    `cd #{destination}\\#{project_name}\\tmp\\application\\ && echo %cd% && ruby .opal_compiler.rb`

  elsif RbConfig::CONFIG['host_os'] =~ /darwin|mac os/
    # code to exec with MacOS
    `cd #{destination}/#{project_name}/tmp/application/;pwd;ruby .opal_compiler.rb`

  else
    # code to exec with Unix/Linux
    `cd #{destination}/#{project_name}/tmp/application/;pwd;ruby .opal_compiler.rb`
  end

end

def add_to_application_folder(script_source, destination, project_name)
  # this method is to add addition script to the application folder (useful for test per example)
  destination_dir = "#{destination}/#{project_name}/application"
  FileUtils.cp_r(Dir["#{script_source}/*"], destination_dir)
end

def build_opal_library(atome_source, destination, project_name, production = nil)

  user_project_path = "#{destination}/#{project_name}"
  opal_directory = "#{user_project_path}/src/js/opal"
  opal_js = "#{opal_directory}/opal.js"
  Dir.mkdir(opal_directory) unless File.directory?(opal_directory)
  File.new opal_js, 'w'
  # we add platform_specific script to the Opal framework
  opal_content = Opal::Builder.build("#{atome_source}/lib/platform_specific/opal/opal.rb").to_s
  File.open(opal_js, 'w') do |f|
    f.puts opal_content
  end
end

def create_application(source, destination, project_name)
  project_path = "#{destination}/#{project_name}"
  FileUtils.mkdir_p(destination) unless Dir.exist?(destination)
  FileUtils.mkdir_p(project_path) unless Dir.exist?(project_path)
  files_list = ['application', 'server', 'src', 'src-tauri', 'src-wasm', 'Guardfile', 'Rakefile']
  file_to_refresh = ['application', 'server', 'src', 'src-tauri', 'Rakefile']
  # we delete many folder to ensure they'll refreshed
  file_to_refresh.each do |file|
    FileUtils.rm_rf("#{destination}/#{project_name}/#{file}")
  end
  # we copy all folder to be refreshed
  files_list.each do |file|
    FileUtils.cp_r("#{source}/vendor/assets/#{file}", "#{destination}/#{project_name}/#{file}")
  end
  build_aui(destination, project_name)
  # now lets add eVe now
  # if eVe_copy
  #   # we update eVe first
  #   gem_spec = Gem::Specification.find_by_name('atome_eVe')
  #   gem_path = gem_spec.gem_dir
  #   puts "eve location : #{gem_path}"
  #   FileUtils.cp_r(Dir["#{gem_path}/*"], source+"/lib/eVe/")
  # end
  # build eVe kernel
  # build_eVe_kernel_for_opal(source, destination, project_name)
end

def update_application(source, destination, project_name)
  project_path = "#{destination}/#{project_name}"
  FileUtils.mkdir_p(destination) unless Dir.exist?(destination)
  FileUtils.mkdir_p(project_path) unless Dir.exist?(project_path)
  files_list = ['application', 'server', 'src', 'src-tauri', 'src-wasm', 'Guardfile', 'Rakefile']
  file_to_refresh = ['application', 'server', 'src',]
  # we delete many folder to ensure they'll refreshed
  file_to_refresh.each do |file|
    FileUtils.rm_rf("#{destination}/#{project_name}/#{file}")
  end
  # we copy all folder to be refreshed
  files_list.each do |file|
    FileUtils.cp_r("#{source}/vendor/assets/#{file}", "#{destination}/#{project_name}/#{file}") unless Dir.exist?(file)
  end
  build_aui(destination, project_name)
end

def build_opal_parser(source, destination, project_name)
  parser_js = "#{destination}/#{project_name}/src/js/opal/opal_parser.js"
  File.new parser_js, 'w'
  parser_content = Opal::Builder.build("#{source}/lib/platform_specific/opal/opal_parser.rb").to_s
  File.open(parser_js, 'w') do |f|
    f.puts parser_content
  end
end

def build_atome_kernel_for_opal(source, destination, project_name)
  #  now lets build the atome kernel
  atome_directory = "#{destination}/#{project_name}/src/js/atome"
  kernel_js = "#{atome_directory}/kernel.js"
  FileUtils.mkdir_p(atome_directory)
  File.new kernel_js, 'w'
  builder = Opal::Builder.new
  builder.append_paths("#{source}/lib/")
  kernel_content = builder.build("#{source}/lib/atome.rb").to_s
  File.open(kernel_js, 'w') do |f|
    f.puts kernel_content
  end
end

# def build_eVe_kernel_for_opal(source, destination, project_name)
#
#   gem_name = 'atome_eVe'
#   # begin
#     Gem::Specification.find_by_name(gem_name)
#     # puts " gem 'eve' est installée."
#     gem_spec = Gem::Specification.find_by_name(gem_name)
#     gem_path = gem_spec.gem_dir
#     # puts "Le chemin vers la gem '#{gem_name}' est '#{gem_path}'"
#   # puts '-----'
#   # puts "==> #{gem_path}/lib/eVe.rb"
#   # rescue Gem::LoadError
#   #   # Code à exécuter si la gemme 'eve' n'est pas installée
#   #   puts "La gem '#{gem_name}' n'est pas installée."
#   # end
#   #  now lets build the atome kernel
#   atome_directory = "#{destination}/#{project_name}/src/js/atome"
#   kernel_js = "#{atome_directory}/eVe_kernel.js"
#   FileUtils.mkdir_p(atome_directory)
#   File.new kernel_js, 'w'
#   builder = Opal::Builder.new
#   builder.append_paths("#{source}/lib/")
#   kernel_content = builder.build("#{gem_path}/lib/eVe.rb").to_s
#   File.open(kernel_js, 'w') do |f|
#     f.puts kernel_content
#   end
# end

def build_opal_extensions(source, destination, project_name)
  opal_directory = "#{destination}/#{project_name}/src/js/opal"
  extensions_js = "#{opal_directory}/atome_opal_extensions.js"
  File.new extensions_js, 'w'
  builder = Opal::Builder.new
  builder.append_paths("#{source}/lib/platform_specific/opal/")
  extensions_content = builder.build("#{source}/lib/platform_specific/opal/atome_opal_extensions.rb").to_s
  File.open(extensions_js, 'w') do |f|
    f.puts extensions_content
  end
end

# wasm compilation
def wasm_common(source, destination, project_name, wasi_file, host_mode, script_source = nil)
  # create_application(source, destination, project_name)
  # the line below is to add addition script to the application folder (useful for test per example)
  add_to_application_folder(script_source, destination, project_name) if script_source
  # build host_mode
  build_host_mode(destination, project_name, host_mode)
  # build wasm
  build_for_wasm(source, destination, project_name, wasi_file)
end

def wasm_initialize (source, destination, project_name, wasi_source)
  application_location = "#{destination}/#{project_name}"
  wasm_location = "#{application_location}/src/wasm/"
  Dir.mkdir(wasm_location) unless Dir.exist?(wasm_location)

  wasm_temp_folder = "#{application_location}/tmp"
  Dir.mkdir(wasm_temp_folder) unless Dir.exist?(wasm_temp_folder)
  #### IMPORTANT TO REFRESH RUBY WASM TO THE LATEST VERSION, (when ruby_browser get far too large)
  # and UNCOMMENT the line  below : ('curl -LO ....')
  unless File.exist?("#{wasm_temp_folder}/ruby-3_2-wasm32-unknown-wasi-full-js.tar.gz")

    if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
      application_location = "#{destination}\\#{project_name}"
      wasm_temp_folder = "#{application_location}\\tmp"
      `cd /d #{wasm_temp_folder} && curl -LO https://github.com/ruby/ruby.wasm/releases/download/2023-11-17-a/ruby-3_2-wasm32-unknown-wasi-full-js.tar.gz
`
    elsif RbConfig::CONFIG['host_os'] =~ /darwin|mac os/
      # code to exec with MacOS
      # `cd #{wasm_temp_folder};curl -LO https://github.com/ruby/ruby.wasm/releases/latest/download/ruby-3_2-wasm32-unknown-wasi-full-js.tar.gz`
      `cd #{wasm_temp_folder};curl -LO https://github.com/ruby/ruby.wasm/releases/download/2023-11-17-a/ruby-3_2-wasm32-unknown-wasi-full-js.tar.gz`
      # debug :  https://github.com/ruby/ruby.wasm/releases/download/2023-11-17-a/ruby-3_2-wasm32-unknown-wasi-minimal-js-debug.tar.gz
      # standard :     `cd #{wasm_temp_folder};curl -LO https://github.com/ruby/ruby.wasm/releases/download/2023-11-17-a/ruby-3_2-wasm32-unknown-wasi-full-js.tar.gz`

    else
      # code to exec with Unix/Linux
      `cd #{wasm_temp_folder};curl -LO https://github.com/ruby/ruby.wasm/releases/download/2023-11-17-a/ruby-3_2-wasm32-unknown-wasi-full-js.tar.gz`
    end

  end

  if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
    # code to exec with Windows
    application_location = "#{destination}\\#{project_name}"

    `cd /d #{wasm_temp_folder} && tar xfz ruby-3_2-wasm32-unknown-wasi-full-js.tar.gz`
    `move #{wasm_temp_folder}\\3_2-wasm32-unknown-wasi-full-js\\usr\\local\\bin\\ruby #{wasm_temp_folder}\\system_ruby_browser.wasm`
    `del #{application_location}\\src\\wasm\\ruby_browser.wasm`
  elsif RbConfig::CONFIG['host_os'] =~ /darwin|mac os/
    # code to exec with MacOS
    `cd #{wasm_temp_folder}; tar xfz ruby-3_2-wasm32-unknown-wasi-full-js.tar.gz`
    `mv #{wasm_temp_folder}/3_2-wasm32-unknown-wasi-full-js/usr/local/bin/ruby #{wasm_temp_folder}/system_ruby_browser.wasm`
    `rm -f #{application_location}/src/wasm/ruby_browser.wasm`
  else
    # code to exec with Unix/Linux
    `cd #{wasm_temp_folder}; tar xfz ruby-3_2-wasm32-unknown-wasi-full-js.tar.gz`
    `mv #{wasm_temp_folder}/3_2-wasm32-unknown-wasi-full-js/usr/local/bin/ruby #{wasm_temp_folder}/system_ruby_browser.wasm`
    `rm -f #{application_location}/src/wasm/ruby_browser.wasm`
  end

  if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
    # code to exec with Windows
    cmd = <<~STRDELIM
      "#{application_location}\\src-wasm\\wasm\\#{wasi_source}" pack "#{wasm_temp_folder}\\system_ruby_browser.wasm"
          -mapdir usr::"#{wasm_temp_folder}\\3_2-wasm32-unknown-wasi-full-js\\usr"
          -mapdir lib::"#{source}\\lib\\"
          -mapdir \::"#{application_location}\\application\\"
          -mapdir utilities::"#{application_location}\\src\\utilities\\"
          -o "#{application_location}\\src\\wasm\\ruby_browser.wasm"
    STRDELIM
  elsif RbConfig::CONFIG['host_os'] =~ /darwin|mac os/
    # code to exec with MacOS
    cmd = <<~STRDELIM
      #{application_location}/src-wasm/wasm/#{wasi_source} pack #{wasm_temp_folder}/system_ruby_browser.wasm
      --mapdir usr::#{wasm_temp_folder}/3_2-wasm32-unknown-wasi-full-js/usr
      --mapdir lib::#{source}/lib/
      --mapdir /::#{application_location}/application/
      --mapdir utilities::#{application_location}/src/utilities/
      -o #{application_location}/src/wasm/ruby_browser.wasm
    STRDELIM
  else
    # code to exec with Unix/Linux
    cmd = <<~STRDELIM
      #{application_location}/src-wasm/wasm/#{wasi_source} pack #{wasm_temp_folder}/system_ruby_browser.wasm
      --mapdir usr::#{wasm_temp_folder}/3_2-wasm32-unknown-wasi-full-js/usr
      --mapdir lib::#{source}/lib/
      --mapdir /::#{application_location}/application/
      --mapdir utilities::#{application_location}/src/utilities/
      -o #{application_location}/src/wasm/ruby_browser.wasm
    STRDELIM
  end

  cleaned_cmd = cmd.lines.reject { |line| line.start_with?('#') }.join
  command = cleaned_cmd.chomp.gsub("\n", ' ')
  system(command)
end

def build_for_wasm(source, destination, project_name, wasi_file)
  wasm_initialize(source, destination, project_name, wasi_file)
end

def build_for_osx(destination, mode = :dev)
  # dev or build
  if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
    # code to exec with Windows
    `cd /d #{destination} && cargo tauri #{mode}`
  elsif RbConfig::CONFIG['host_os'] =~ /darwin|mac os/
    # code to exec with MacOS
    `cd #{destination};cargo tauri #{mode}`
  else
    # code to exec with Unix/Linux
    `cd #{destination};cargo tauri #{mode}`
  end

end

def init_server(destination, project_name, port, prod, ru_file)

  if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
    # code to exec with Windows
    File.open("#{destination}\\#{project_name}\\server\\config.ru", "w") do |f|
      f.write(ru_file)
    end
    # `cd /d #{destination}\\#{project_name}\\server && puma --port #{port} #{prod}`
    # system("start cmd /c cd /d #{destination}\\#{project_name}\\server && puma --port #{port} #{prod}")
    system("cd /d \"#{destination}\\#{project_name}\\server\" && puma --port #{port} #{prod}")

  elsif RbConfig::CONFIG['host_os'] =~ /darwin|mac os/
    # code to exec with MacOS
    File.open("#{destination}/#{project_name}/server/config.ru", "w") do |f|
      f.write(ru_file)
    end
    # `cd #{destination}/#{project_name}/server;puma --port #{port} #{prod}`
    system("cd #{destination}/#{project_name}/server && puma --port #{port} #{prod}")

  else
    # code to exec with Unix/Linux
    File.open("#{destination}/#{project_name}/server/config.ru", "w") do |f|
      f.write(ru_file)
    end
    # `cd #{destination}/#{project_name}/server;puma --port #{port} #{prod}`
    system("cd #{destination}/#{project_name}/server && puma --port #{port} #{prod}")
  end
end

def build_for_opal_server(destination, project_name, port, production, run_server = true)
  if production
    prod = '--env production'
    ru_file = <<STR
require 'roda'
require './atome_server.rb'
run App.app.freeze
STR
  else
    ru_file = <<STR
require 'roda'
require 'rack/unreloader'
Unreloader = Rack::Unreloader.new(subclasses: %w[Roda]) { App }
Unreloader.require './atome_server.rb'
run Unreloader
require './atome_server.rb'
STR
  end
  if run_server ==true
    init_server(destination, project_name, port, prod, ru_file)
  end

end

def build_for_wasm_server(destination, project_name, port, production, run_server = true)
  if production
    prod = '--env production'
    ru_file = <<STR
require 'roda'
require './atome_server_wasm.rb'
run App.app.freeze
STR
  else
    ru_file = <<STR
require 'roda'
require 'rack/unreloader'
Unreloader = Rack::Unreloader.new(subclasses: %w[Roda]) { App }
Unreloader.require './atome_server_wasm.rb'
run Unreloader
require './atome_server.rb'
STR
  end
  if run_server ==true
    init_server(destination, project_name, port, prod, ru_file)
  end
  # if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
  #   # code to exec with Windows
  #   File.open("#{destination}\\#{project_name}\\server\\config.ru", "w") do |f|
  #     f.write(ru_file)
  #   end
  #   `cd /d #{destination}\\#{project_name}\\server && puma --port #{port} #{prod}`
  # elsif RbConfig::CONFIG['host_os'] =~ /darwin|mac os/
  #   # code to exec with MacOS
  #   File.open("#{destination}/#{project_name}/server/config.ru", "w") do |f|
  #     f.write(ru_file)
  #   end
  #   `cd #{destination}/#{project_name}/server;puma --port #{port} #{prod}`
  # else
  #   # code to exec with Unix/Linux
  #   File.open("#{destination}/#{project_name}/server/config.ru", "w") do |f|
  #     f.write(ru_file)
  #   end
  #   `cd #{destination}/#{project_name}/server;puma --port #{port} #{prod}`
  # end

end

# utils
def ensure_rb_extension(filename)
  filename.end_with?('.rb') ? filename : "#{filename}.rb"
end

def find_requires(file)
  requires = []
  File.foreach(file) do |line|
    trimmed_line = line.strip
    if trimmed_line.start_with?('require ') || trimmed_line.start_with?('require_relative ')
      match = trimmed_line.match(/['"]([^'"]+)['"]/)
      if match
        path = match[1].end_with?('.rb') ? match[1][0...-3] : match[1]
        requires << path
      end
    end
  end
  requires
end

def copy_file(source, destination)
  return if source == 'server.rb'

  FileUtils.mkdir_p(File.dirname(destination))
  FileUtils.cp(source, destination)
end

def copy_with_requires(source, destination, base_folder)
  destination_file = File.join(destination, source.sub(base_folder + '/', ''))
  copy_file(source, destination_file)
  find_requires(source).each do |relative_path|
    required_file = File.join(base_folder, "#{relative_path}.rb")
    copy_with_requires(required_file, destination, base_folder) if File.exist?(required_file)
  end
end

# below we analyse the ARGV
location = if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
             # code to exec with Windows
             '\\'
           elsif RbConfig::CONFIG['host_os'] =~ /darwin|mac os/
             # code to exec with MacOS
             '/'
           else
             # code to exec with Unix/Linux
             '/'
           end

project_name = ARGV[1]

if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
  # code to exec with Windows
  destination = `cd`.chomp
  wasi_file = 'wasi-vfs.exe'

elsif RbConfig::CONFIG['host_os'] =~ /darwin|mac os/
  # code to exec with MacOS
  destination = `pwd`.chomp
  wasi_file = 'wasi-vfs-osx_arm' # default to osx arm
else
  # code to exec with Unix/Linux
  destination = `pwd`.chomp
  wasi_file = 'wasi-vfs-unix'
end

source = Pathname(__FILE__).parent.parent.to_s

# TODO : get wasi params from ARG to allow compile on windows / Unix
if ARGV.include?('create')
  create_application(source, destination, project_name)
  # create_application(source, destination, project_name, production)
  # build opal
  build_opal_library(source, destination, project_name)
  # build parser
  build_opal_parser(source, destination, project_name)
  # build atome kernel
  build_atome_kernel_for_opal(source, destination, project_name)
  # build host_mode
  build_host_mode(destination, project_name, 'web-opal')
  # build Opal extensions
  build_opal_extensions(source, destination, project_name)
  # build application
  build_opal_application(source, destination, project_name)
end

if ARGV.include?('update')

  gem_name = 'atome'
  local_gem_spec = Gem::Specification.find_by_name(gem_name) rescue nil
  # if local_gem_spec.nil?
  #   puts :case1
  #   puts " #{gem_name} gem  is not install will install from distant server"
  #   system("gem update #{gem_name}")
  # else
  #   puts :case2
  #
  #   available_versions = Gem::Specification.find_all_by_name(gem_name).map(&:version)
  #
  #   latest_version = available_versions.max
  #
  #   if latest_version > local_gem_spec.version
  #     puts "update availlable: #{local_gem_spec.version} -> #{latest_version}"
  #     system("gem update #{gem_name}")
  #   else
  #     puts "No update necessary '#{gem_name}'. current version : #{local_gem_spec.version}"
  #   end
  # end
  #########
  # if local_gem_spec.nil?
  #   puts :case1
  #   puts " #{gem_name} gem  is not install will install from distant server"
    system("gem update #{gem_name}")
  # else
  #   puts :case2

    available_versions = Gem::Specification.find_all_by_name(gem_name).map(&:version)

    latest_version = available_versions.max

    if latest_version > local_gem_spec.version
      puts "update availlable: #{local_gem_spec.version} -> #{latest_version}"
      system("gem update #{gem_name}")
    else
      puts "No update necessary '#{gem_name}'. current version : #{local_gem_spec.version}"
    end
  # end

  ########
  # TODO: also update index.html and all other files except the application folder
  # we check we are in atome app
  if Dir.exist?("#{destination}/application") && !Dir.exist?("#{destination}/vendor")
    # first we delete everything but application

    files_to_treat = %w[server src-tauri src-wasm Guardfile Rakefile src/css src/js/atome src/js/molecules src/js/third_parties
src/favicon.ico src/index_wasm.html src/index_opal.html src/index_server.html src/index_server_wasm.html]
    files_to_treat.each do |item|
      item_path = File.join(destination, item)
      if File.directory?(item_path)
        FileUtils.rm_rf(item_path) unless item == '.' || item == '..'
      elsif File.file?(item_path)
        File.delete(item_path)
      end
      source_item = "#{source}/vendor/assets/#{item}"
      FileUtils.cp_r(source_item, item)
    end
    # now rebuilding aop lib
    # build opal
    build_opal_library(source, destination, project_name)
    # build parser
    build_opal_parser(source, destination, project_name)
    # build atome kernel
    build_atome_kernel_for_opal(source, destination, project_name)
    # build host_mode
    build_host_mode(destination, project_name, 'web-opal')
    # build Opal extensions
    build_opal_extensions(source, destination, project_name)
    # build application
    build_opal_application(source, destination, project_name)

    ########################

    # unless Dir.exist?("#{destination}/vendor")
    #   Dir.mkdir("#{destination}/vendor")
    # end

    #######################

    puts "your application is up to date"
  end

  # now we get the version of the atome gem
  gem_name = 'atome'
  local_gem_spec = Gem::Specification.find_by_name(gem_name) rescue nil
  latest_version=local_gem_spec.version
  puts "#{gem_name} #{latest_version} is now installed "

end

current_path = Pathname.new(Dir.pwd)
project_name = current_path.basename.to_s
destination = current_path.parent.to_s

if ARGV.include?('run')
  case ARGV[1]
  when 'opal'

    guard_content = <<STR
guard 'rake', first_match: true, :task => 'build_opal' do
  watch(%r{^server.+\.rb})
  watch(%r{^application.+\.rb})
end
STR

    File.open("./#{location}/Guardfile", "w") do |f|
      f.write(guard_content)
    end
    puts 'guarding'
    Dir.chdir("./#{location}") do
      `guard`
    end
  when 'wasm' # osx wasi
    guard_content = <<STR
guard 'rake', first_match: true, :task => 'build_wasm' do
  watch(%r{^server.+\.rb})
  watch(%r{^application.+\.rb})
end
STR

    File.open("./#{location}/Guardfile", "w") do |f|
      f.write(guard_content)
    end
    puts 'guarding'
    Dir.chdir("./#{location}") do
      `guard`
    end
  when 'server'
    guard_content = <<STR
guard 'rake', first_match: true, :task => 'build_server' do
  watch(%r{^server.+\.rb})
  watch(%r{^application.+\.rb})
end

STR

    File.open("./#{location}/Guardfile", "w") do |f|
      f.write(guard_content)
    end
    puts 'guarding'
    threads = []
    Dir.chdir("./#{location}") do
      threads << Thread.new do
        `guard`
      end
    end
  when 'osx'
  when 'android'
    # to be filled
  when 'ios'
    # to be filled
  when 'windows'
    # to be filled
  when 'linux'
    # to be filled
  when 'freebsd'
    # to be filled
  end

end

if ARGV.include?('sparkle')
  temp_dir = if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
               'C:\Windows\Temp'
               # code to exec with Windows
             elsif RbConfig::CONFIG['host_os'] =~ /darwin|mac os/
               '/tmp'
               # code to exec with MacOS
             else
               '/tmp'
               # code to exec with Unix/Linux
             end

  `cd #{temp_dir}; atome create atome_app` unless Dir.exist?("#{temp_dir}/atome_app")
  # search for server file
  if File.exist?('server.rb')
    file_content = File.read('server.rb')
    File.write("#{temp_dir}/atome_app/server/atome_server.rb", file_content)
    base_folder = File.dirname(project_name)
    copy_with_requires('server.rb', "#{temp_dir}/atome_app/server", base_folder)
  end
  project_name = ARGV[1]
  if project_name.nil? || project_name == 'opal' || project_name == 'wasm' || project_name == 'server'
    project_name = 'index.rb'
  end
  project_name = ensure_rb_extension(project_name)
  base_folder = File.dirname(project_name)
  copy_with_requires(project_name, "#{temp_dir}/atome_app/application", base_folder)

  if ARGV.include?('opal')
    `cd #{temp_dir}/atome_app;atome run opal`

  elsif ARGV.include?('wasm')
    `cd #{temp_dir}/atome_app;atome run wasm`

  elsif ARGV.include?('server')
    `cd #{temp_dir}/atome_app;atome run server`
  else
    `cd #{temp_dir}/atome_app;atome run opal`
  end
else
  if ARGV.include?('opal')
    puts 'building Opal'

    build_opal_application(nil, destination, project_name)
    # build host_mode
    build_host_mode(destination, project_name, 'web-opal')
    # build Opal extensions
    if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
      # code to exec for Windows
      `start "" "#{destination}\\#{project_name}\\src\\index_opal.html"`
    elsif RbConfig::CONFIG['host_os'] =~ /darwin|mac os/
      # code to exec for MacOS
      `open #{destination}/#{project_name}/src/index_opal.html`
    else
      # code to exec for Unix/Linux
      `open #{destination}/#{project_name}/src/index_opal.html`
    end

    puts "opal ready!"
  end

  if ARGV.include?('wasm')
    puts 'building Ruby wasm'
    wasi_file = 'wasi-vfs-osx_arm'
    wasm_common(source, destination, project_name, wasi_file, :pure_wasi)

    if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
      # code to exec for Windows
      `start "" "#{destination}\\#{project_name}\\src\\index_wasm.html"`
    elsif RbConfig::CONFIG['host_os'] =~ /darwin|mac os/
      # code to exec for MacOS
      `open #{destination}/#{project_name}/src/index_wasm.html`
    else
      # code to exec for Unix/Linux
      `open #{destination}/#{project_name}/src/index_wasm.html`
    end

  end

  if ARGV.include?('server')
    puts 'building Server'
    build_opal_application(nil, destination, project_name)
    build_host_mode(destination, project_name, 'web-opal')
    threads = []
    threads << Thread.new do
      # sleep 1
      # if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
      #   # code to exec with Windows
      #   `start "" "#{destination}\\#{project_name}\\src\\index_server.html`
      # elsif RbConfig::CONFIG['host_os'] =~ /darwin|mac os/
      #   # code to exec with MacOS
      #   `open http://localhost:9292`
      # else
      #   # code to exec with Unix/Linux
      #   `open http://localhost:9292`
      # end
    end
    threads << Thread.new do
      build_for_opal_server(destination, project_name, 9292, false)
    end

    threads.each(&:join)

  end

  if ARGV.include?('wasm_server')
    puts 'building Server'
    build_opal_application(nil, destination, project_name)
    build_host_mode(destination, project_name, 'web-opal')
    threads = []
    # threads << Thread.new do
    #   # sleep 1
    #   # if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
    #   #   # code to exec with Windows
    #   #   `start "" "#{destination}\\#{project_name}\\src\\index_server.html`
    #   # elsif RbConfig::CONFIG['host_os'] =~ /darwin|mac os/
    #   #   # code to exec with MacOS
    #   #   `open http://localhost:9292`
    #   # else
    #   #   # code to exec with Unix/Linux
    #   #   `open http://localhost:9292`
    #   # end
    # end
    threads << Thread.new do
      build_for_wasm_server(destination, project_name, 9292, false)
    end
    threads.each(&:join)
    puts 'wasm server is running'
  end

  if ARGV.include?('server_refresh')
    puts 're building Server'
    build_opal_application(nil, destination, project_name)
    timestamp = Time.now.strftime("%Y%m%d%H%M%S")

    if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
      # code to exec with Windows
      # `start #{destination}\\#{project_name}\\src\\index_server.html`
      `start   http://localhost:9292?date=#{timestamp}`
    elsif RbConfig::CONFIG['host_os'] =~ /darwin|mac os/
      # code to exec with MacOS
      `open http://localhost:9292?date=#{timestamp}`
    else
      # code to exec with Unix/Linux
      `open http://localhost:9292?date=#{timestamp}`
    end
  end

  if ARGV.include?('osx')
    puts 'building osx'
    wasi_file = 'wasi-vfs-osx_arm'
    wasm_common(source, destination, project_name, wasi_file, :tauri)
    build_for_osx(destination)
  end

  puts 'building Android' if ARGV.include?('android')
  puts 'building iOS' if ARGV.include?('ios')
  puts 'building Windows' if ARGV.include?('windows')
  puts 'building Linux' if ARGV.include?('linux')
  puts 'building Freebsd' if ARGV.include?('freebsd')

end