require 'json'
require 'find'
require 'fileutils'
require 'optparse'

ARGV << '-h' if ARGV.empty?
@jsonprovided = false
@pathprovided = false
ARGV.each do |i|
  @jsonprovided = i.include?("-j") ? true : i.include?("--json") ? true : false unless @jsonprovided == true
  @pathprovided = i.include?("-p") ? true : i.include?("--path") ? true : false unless @pathprovided == true
end

ARGV.clear && ARGV[0] = '-h'  if @jsonprovided == false || @pathprovided == false

options = OpenStruct.new

def validateparam(param, option)
  if param[0] == '-'
    puts "Wrong argument passed to #{option}!!"
    exit
  end
end

OptionParser.new do |opts|

  options.recreate = false
  options.log = "auto"
  options.env = nil
  options.data = nil
  options.app = nil

  opts.banner = "Usage: deployvm.rb [options]"

  opts.separator ""
  opts.separator "Specific options:"

  opts.on("-jJSON", "--json-file=JSON", "REQUIRED : Json Provision File (machine name) ex.: ldcpjambon01") do |json|
    validateparam(json, "--json-file")
    options.json = json
  end

  opts.on("-pPATH", "--path-json=PATH", "REQUIRED : Path to json provision file ex.: /home/path/to/prov") do |path|
    validateparam(path, "--path-json")
    options.path = path
  end

  opts.on("-aAPP", "--app-name=APP", "OPTIONAL : Application name for multi-file provisioning") do |app|
    options.app = app
  end

  opts.on("-dDATA", "--data-center=DATA", "OPTIONAL : Data center : LDC or CDC") do |data|
    options.data = data
  end

  opts.on("-eENV", "--env=ENV", "OPTIONAL : Environment (Prod[p], Preprod[x], UAT[i], QA[q], Training[t], Test[s], Dev[d])") do |env|
    options.env = env
  end

  opts.on("-lLOG", "--log-level=LOG", "OPTIONAL : Chef run log level [auto error warn info debug] (default auto)") do |log|
    options.log = log
  end

  opts.on("-r", "--recreate", "OPTIONAL : Recreate machine (default no)") do |rec|
    options.recreate = rec
  end

  opts.on_tail("-h", "--help", "Show this message") do
    puts opts
    exit
  end

  options

end.parse!

application_name = options.app unless options.app.nil?
regionoption = options.data unless options.data.nil?
environmentoption = options.env unless options.env.nil?
provisionfileparameter = options.json.include?("json") ? "#{options.json}" : "#{options.json}.json"
path_to_json_files = options.path[-1,1] == "/" ? options.path : "#{options.path}/"
chef_log_level = options.log
options.recreate ? recreatemachine = true : recreatemachine = false
parser_used = true



node_name = "jproven3"
vsphere_user = "YPG\\#{node_name}"
vsphere_password = ""
unless File.exist?("#{ENV["HOME"]}/.chef/dev_#{node_name}.pem") || File.exist?("#{ENV["HOME"]}/.chef/new_#{node_name}.pem")
  puts "WARNING!"
  puts "You are missing either the dev_#{node_name}.pem file or new_#{node_name}.pem file!! (in #{ENV["HOME"]}/.chef)"
  puts "Please run sross1's chef setup script!"
  exit
end
client_key = File.new("#{ENV["HOME"]}/.chef/#{node_name}.pem")
client_key_dev = File.new("#{ENV["HOME"]}/.chef/dev_#{node_name}.pem")
client_key_new = File.new("#{ENV["HOME"]}/.chef/new_#{node_name}.pem")
puts "client_key.class = #{client_key.class}"
cookbookdependencies = ["yp_devops_deployement"]
runlist = ["yp_devops_deployement"]
cookbookfolder = Dir.new("#{ENV["HOME"]}/cookbooks/")
puts "cookbookfolder.class = #{cookbookfolder.class}"
deployrepo = "/tmp/deployrepo"
vssshkeypath = File.new("#{cookbookfolder.class == Dir ? cookbookfolder.path : cookbookfolder}/yp_devops_deployement/files/default/id_rsa_chef_deployer")
cookbooknameprefix = "deployrepo__"
cookbookname = "#{cookbooknameprefix}"



FileUtils.rm_rf(deployrepo) if Dir.exist?(deployrepo)

def getjsonfile(filename, dir_contain_json)
  return_json = nil
  if !File.exist?(filename)
    Find.find(dir_contain_json) do |path|
      if Dir.exist?(path)
        next
      else
        return_json = File.file?(path) ? File.new(path) : path
        break if File.basename(return_json) == File.basename(filename)
      end
    end
  else
    return_json = File.new(filename)
  end
  return_json.nil? ? nil : File.realpath(return_json)
end

provisionfile = getjsonfile(provisionfileparameter, path_to_json_files)

environmentoption = provisionfileparameter[3] if environmentoption.nil?
environmentparameter = case environmentoption.upcase
when "PROD", "P"
      "p"
  when "PREPROD", "X"
      "x"
  when "UAT", "I"
      "i"
  when "QA", "Q"
      "q"
  when "TRAINING", "T"
      "t"
  when "TEST", "S"
      "s"
  when "DEV", "D"
      "d"
  else
    puts "Invalid env #{environmentoption}"
    exit
end

regionsuffix = "#{environmentparameter}#{application_name}"

regionoption = provisionfileparameter[0..2] if regionoption.nil?
regionfileparameter = case regionoption.upcase
  when "CDC"
      "cdc#{regionsuffix}.json"
  when "LDC"
      "ldc#{regionsuffix}.json"
  else
      puts "Invalid / No region parameter set (region = #{regionoption})"
      exit 108
end

regionfile = getjsonfile(regionfileparameter, path_to_json_files)

applicationfileparameter="#{application_name}.json"
applicationfile = getjsonfile(applicationfileparameter, path_to_json_files)

cookbookdependsreplacement = cookbookdependencies.map {|cookbook| "depends '#{cookbook}'"}

def buildmachine(recreatemachine, actualfolder, deployrepo, cookbooknameprefix, cookbookname, cookbookfolder, provisionfile, regionfile, applicationfile, cookbookdependsreplacement, runlist, node_name, client_key, client_key_dev, client_key_new, chef_log_level, vssshkeypath, vsphere_user, vsphere_password)
    Dir.chdir(actualfolder)
  Dir.mkdir(deployrepo) if !Dir.exist?(deployrepo)
    Dir.chdir(deployrepo)
  FileUtils.rm_rf(cookbooknameprefix)
  puts "Generating deployment cookbook"
    system("chef generate cookbook #{cookbookname} > /dev/null")

    Dir.chdir(cookbookname)

  nodepath = File.join(Dir.pwd, File.join('nodes',File.basename(provisionfile)))
    solofile = File.join(Dir.pwd, 'solo.rb')
    tmpprovisionfile = File.join(Dir.pwd, File.basename(provisionfile))

  FileUtils.rm_rf(File.dirname(nodepath))
  Dir.mkdir(File.dirname(nodepath))

  File.open("Berksfile", "w") do |file|
    file.puts "source 'https://supermarket.chef.io'\nsource :chef_server\n\nmetadata".each_line {|line| line}
  end
    # puts "\nBerksfile\n" + File.read("Berksfile")

  File.open("metadata.rb", "a+") do |file|
    file.puts cookbookdependsreplacement.join("\n").each_line {|line| line}
  end
    # puts "\nmetadata.rb\n" + File.read("metadata.rb")



  puts "Fetch require cookbooks"
  system("berks vendor --delete \"#{deployrepo.path}\" > /dev/null")
  customcred =
  {
    "deployeroptions": {
      "VS_SSH_KEY": vssshkeypath.class == File ? vssshkeypath.path : vssshkeypath,
      "vsphere_user": vsphere_user,
      "vsphere_password": vsphere_password
    },
    "run_list": runlist
  }
  nodejson = JSON.parse(File.read(provisionfile)).to_h
  puts "\nnodejson = #{nodejson}\n"
  regionjson = JSON.parse(File.read(regionfile)).to_h unless regionfile.nil?
  puts "\nregionjson = #{regionjson}\n" unless regionjson.nil?
  appjson = JSON.parse(File.read(applicationfile)).to_h unless applicationfile.nil?
  puts "\nappjson = #{appjson}\n" unless appjson.nil?
  if ! regionjson.nil? || ! appjson.nil?
    all_merged = appjson.deep_merge(regionjson).deep_merge(nodejson).deep_merge(customcred)
  elsif regionjson.nil? || ! appjson.nil?
    all_merged = appjson.deep_merge(nodejson).deep_merge(customcred)
  elsif ! regionjson.nil? || appjson.nil?
    all_merged = regionjson.deep_merge(nodejson).deep_merge(customcred)
  else
    all_merged = nodejson.deep_merge(customcred)
  end

  puts "\nmerged_json = #{all_merged}"
  finalclientkey = all_merged["ypchef"]["chefserver"].include?("chefdev") ? client_key_dev : all_merged["ypchef"]["chefserver"].include?("chefsrv") ? client_key_new : client_key
  puts ("final client key = #{finalclientkey.path}")

  File.open(solofile, "w") do |file|
    file.puts "cookbook_path [\n\t'#{cookbookfolder.path}'\n]\nnode_path '#{nodepath}'\nnode_name '#{node_name}'\nclient_key '#{finalclientkey.path}'\nsolo true\nlog_level :#{chef_log_level}".each_line {|line| line}
  end

  File.open("all_merged.json", "w") do |file|
    file.puts JSON.pretty_generate(all_merged)
  end
  puts "\nall_merged.json\n" + File.read("all_merged.json")

    if recreatemachine == true
    then
        puts "\nDestroying the machine"
    destroyhash = all_merged.deep_merge({"ypvm": {"action": "destroy"}}.transform_keys{|k| k.to_s})
    File.open("alldestroy.json", "w") do |file|
      file.puts JSON.pretty_generate(destroyhash)
    end
    # puts "\nalldestroy.json\n" + File.read("alldestroy.json")
        system("chef-solo -c solo.rb -j \"alldestroy.json\"")
        puts "\nRebuilding the machine"
    nodefile = File.join("nodes",File.join(File.basename(provisionfile),"#{node_name}.json"))
    nodeinfo = JSON.parse(File.read(nodefile)).to_h
    nodeinfo["normal"]["ypvm"]["action"] = "converge"
    File.open(nodefile, "w") do |file|
      file.puts JSON.pretty_generate(nodeinfo)
    end
  end
  # machinename1 = provisionfile.split('.')[0].split('/').last
  # system("#{ENV["HOME"]}/.chef/knife.sh dev vault update ssh_private_keys root -C #{machinename1}")
    system("chef-solo -c solo.rb -j \"all_merged.json\"")
end

class ::Hash
  def deep_merge(second)
      merger = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : Array === v1 && Array === v2 ? v1 | v2 : [:undefined, nil, :nil].include?(v2) ? v1 : v2  }
      # puts "\nMerging json1\n#{self}\n\n with json2\n#{second}"
      self.merge(second, &merger)
  end
end

buildmachine(recreatemachine, Dir.pwd, deployrepo, cookbooknameprefix, cookbookname, cookbookfolder, provisionfile, regionfile, applicationfile, cookbookdependsreplacement, runlist, node_name, client_key, client_key_dev, client_key_new, chef_log_level, vssshkeypath, vsphere_user, vsphere_password)