##Copyright 2023 ByteDance Ltd. and/or its affiliates
##SPDX-License-Identifier: MIT

require 'cocoapods'
require_relative 'net'
require_relative 'config'
require_relative 'tool'



module Pod
  class Specification

    def get_default_subspec_name
      @attributes_hash["default_subspecs"].first
    end

    def get_subspecs
      # default_name = @attributes_hash["default_subspecs"].first
      subspecs = []
      name_list_a = []
      rely_spec_version = ""
      @subspecs.map do |spec|
        puts "s:#{spec.class}"
        get_dependencies spec.name
      end
    end

    def get_dependencies(spec_name)
      depens =  spec.dependencies
      # name_list = []
      # depens.map do |den|
      #   if den.name.length > 0
      #     name_list | get_dependencies den.name
      #     name_list << den.name
      #   end
      # end if depens.length > 0
      # name_list
    end

    # def get_specfication(spec_name)
    # end

    def get_rely_version
      hash = @attributes_hash

      subs = @subspecs
      subs
      dep_accurate_sperc = @subspecs.select do |spec|
        spec.name == "Ads-Global-Beta/Dep_Accurate"
      end.first
      dep_accurate_sperc.dependencies.first.get_requirment
    end
  end

  class  Dependency
    def get_requirment
      @requirement.requirements.first.last.version
    end
  end
end

module PM

  # 记录Pangle SDK版本信息
  #
  class Info
    attr_accessor :name
    attr_accessor :version
    def initialize(name, version)
      @name = name
      @version = version
    end

    def to_hash
      hash = {}
      hash["NAME"] = @name
      hash["VERSION"] = @version
      hash
    end

    def self.from_hash(hash)
      Info.new(hash["NAME"],hash["VERSION"])
    end
  end

  # SDK 信息
  class SDKInfo < Info
  end

  # Mediation信息
  class MInfo < Info
  end

  # 配置信息
  #
  class  Note
    attr_accessor :auto_load
    attr_accessor :auto_update
    attr_accessor :load_detect
    def get_update(update_value)
      value = ''
      case update_value
      when true
        value = PM::BuildConfig.update_value_last_version
      when false
        value = PM::BuildConfig.update_value_non
      when String
        value = update_value
      else
        raise ArgumentError, "CSJM error: `#{update_value.inspect}`, should be a boolean or string."
      end
      value
    end
  end

  class GlobalNote < Note
    attr_accessor :auto_load_whitelist
    attr_accessor :use_service_local
    attr_reader   :is_release
    def initialize(auto_load = true , auto_update = PM::BuildConfig.update_value_last_version, load_detect = true, auto_load_whitelist = {},is_release = false)
      @auto_load = auto_load
      @auto_update = get_update auto_update
      @load_detect = load_detect
      @auto_load_whitelist = auto_load_whitelist
      @is_release = is_release
    end

    def to_hash
      hash = {}
      hash["AUTO_LOAD"] = @auto_load
      hash["AUTO_UPDATE"] = @auto_update
      hash["LOAD_DETECT"] = @load_detect
      hash["AUTO_LOAD_WHITELIST"] = @auto_load_whitelist
      hash
    end

    def self.from_hash(hash)
      global_note =  GlobalNote.new()
      global_note.auto_load = hash["AUTO_LOAD"] if hash.has_key?("AUTO_LOAD")
      global_note.auto_update = hash["AUTO_UPDATE"] if hash.has_key?("AUTO_UPDATE")
      global_note.load_detect = hash["LOAD_DETECT"] if hash.has_key?("LOAD_DETECT")
      global_note.auto_load_whitelist = hash["AUTO_LOAD_WHITELIST"] if hash.has_key?("AUTO_LOAD_WHITELIST")
      global_note
    end
  end

  class AdnNote < Note

    attr_accessor :adn_name
    attr_accessor :adn_version
    attr_accessor :adapter_name
    attr_accessor :adapter_original_version ##加载的版本号
    attr_accessor :adapter_expected_version ##期望加载的版本号

    def initialize(adn_name, auto_load = false , auto_update = PM::BuildConfig.update_value_non, load_detect = false)
      @adn_name = adn_name
      @adapter_name = PM::MapRelations.get_adapter adn_name
      @auto_load = auto_load
      @auto_update = get_update auto_update
      @load_detect = load_detect
    end

    def to_hash
      hash = {}
      hash["ADN_NAME"] = @adn_name
      hash["ADN_VERSION"] = @adn_version
      hash["ADAPTER_NAME"] = @adapter_name
      hash["ADAPTER_ORIGINAL_VERSION"] = @adapter_original_version
      hash["ADAPTER_EXPECTED_VERSION"] = @adapter_expected_version
      hash["AUTO_LOAD"] = @auto_load
      hash["AUTO_UPDATE"] = @auto_update
      hash["LOAD_DETECT"] = @load_detect
      hash
    end

    def self.from_hash(hash)
      note =  AdnNote.new(hash["ADN_NAME"],hash["AUTO_LOAD"],hash["AUTO_UPDATE"],hash["LOAD_DETECT"])
      note.adn_name = hash["ADN_NAME"]
      note.adn_version = hash["ADN_VERSION"]
      note.adapter_name = hash["ADAPTER_NAME"]
      note.adapter_original_version = hash["ADAPTER_ORIGINAL_VERSION"]
      note.adapter_expected_version = hash["ADAPTER_EXPECTED_VERSION"]
      note
    end
  end

  class UpdateResut
    attr_accessor :is_sdk_update
    attr_accessor :is_rely_update
    attr_accessor :sdk_list
    attr_accessor :rely_list
    attr_accessor :sdk_name
    attr_accessor :rely_name
    attr_accessor :sdk_original_version
    attr_accessor :rely_original_version
    attr_accessor :sdk_target_version
    attr_accessor :rely_target_version

    def initialize()
      @is_sdk_update = false
      @is_rely_update = false
      @sdk_list = []
      @rely_list = []
    end

    def self.from_hash(hash)
      re = UpdateResut.new()
      re.sdk_name =  "Ads-Global"
      re.rely_name = "BURelyFoundation_Global"
      re.sdk_original_version = hash["SDK_ORIGINAL_VERSION"]
      re.sdk_target_version = hash["SDK_TARGET_VERSION"]
      re.rely_original_version = hash['RELY_ORIGINAL_VERSION']
      re.rely_target_version = hash['RELY_TARGET_VERSION']
      re.is_sdk_update = re.sdk_original_version != re.sdk_target_version
      re.is_rely_update = re.rely_original_version != re.rely_target_version
      info_r = PM::SpecificationInfo.get_info
      re.sdk_list = info_r[re.sdk_name].select do |spec|
        Pod::Specification.root_name(spec.name) == re.sdk_name && spec.version.version == re.sdk_target_version
      end
      re.rely_list = info_r[ re.rely_name].select do |spec|
        Pod::Specification.root_name(spec.name) ==  re.rely_name && spec.version.version == re.rely_target_version
      end
      re
    end

  end
  # 配置信息 (cocoapods target维度下)
  #
  class Target

    attr_accessor :is_release_target
    attr_accessor :referenced_target
    attr_reader   :label
    attr_accessor :PM_info
    attr_accessor :nots_info

    def initialize(label)
      @label = label.clone
      @is_release_target = false
    end

    def find_note(adn_name)
      @nots_info ||= {}
      global_note = PM::Recorder.instance.global_note
      note = (@nots_info.has_key?(adn_name) && @nots_info[adn_name]) || AdnNote.new(adn_name, global_note.auto_load, global_note.auto_update, global_note.load_detect)
      @nots_info[adn_name] = note unless @nots_info.has_key?(adn_name)
      note
    end

    def has_adn?(adn_name)
      PM::MapRelations.is_adn?(adn_name) && @nots_info.has_key?(adn_name)
    end

    def is_adn_update_or_detect?(adn_name)
      result =  is_adn_update?(adn_name) || is_adn_detect?(adn_name)
      result
    end

    def is_adn_update?(adn_name)
      result = has_adn?(adn_name) && @nots_info[adn_name].auto_update != PM::BuildConfig.update_value_non
      result
    end

    def is_adn_detect?(adn_name)
      has_adn?(adn_name) && @nots_info[adn_name].load_detect
    end

    def to_hash
      hash = {}
      hash["LABEL"] = @label
      hash["IS_RELEASE_TARGET"] = @is_release_target
      hash["PM_INFO"] = @pm_info.to_hash
      hash["NOTS_INFO"] = {}
      @nots_info.each {|key, value|
        hash["NOTS_INFO"][key] = value.to_hash
      }
      hash
    end

    def self.from_hash(hash)
      target = Target.new(hash["LABEL"])
      target.is_release_target = true
      target.PM_info = PMInfo.from_hash hash["PM_INFO"] if hash.has_key?("PM_INFO")
      target.nots_info ||= {}
      hash["NOTS_INFO"].each do |name, note_info|
        target.nots_info[name] = AdnNote.from_hash note_info
      end
      target
    end

  end

  # 记录方
  #
  class Recorder

    include Singleton
    attr_accessor :global_note
    attr_accessor :target_info
    attr_accessor :sdk_original_version
    attr_accessor :rely_original_version
    attr_accessor :sdk_target_version
    attr_accessor :rely_target_version
    attr_accessor :adapter_list
    attr_reader :is_load_plugin
    attr_reader :plugin_version
    attr_reader :lockfile_data
    attr_reader :is_debug


    def initialize()
      @adapter_list = []
      @is_debug = false
    end

    def set_plugin_load(is_load)
      @is_load_plugin = is_load
      @plugin_version = CocoapodsBytePanglem::Version.version
    end

    def set_is_debug(is_debug)
      @is_debug = is_debug
    end

    def add_global_note(note)
      @global_note = note
    end

    def find_global_note(option, is_force_update = false)

      return @global_note if !is_force_update && @global_note != nil
      @global_note = GlobalNote.new(false, PM::BuildConfig.update_value_non, false)
      load_key        = PM::BuildConfig.get_load_key
      update_key      = PM::BuildConfig.get_update_key
      load_detect_key = PM::BuildConfig.get_load_detect_key
      auto_load_whitelist_key = PM::BuildConfig.get_load_whitelist_key
      is_release_key = PM::BuildConfig.get_is_release_key
      use_service_local_key = PM::BuildConfig.get_use_service_local_key

      case option
      when true, false
        @global_note =  PM::GlobalNote.new(option,option,option,{})
      when Hash
        load_value = option.has_key?(load_key) ? option[load_key] : true
        update_value = option.has_key?(update_key) ? option[update_key] : true
        detect_value = option.has_key?(load_detect_key) ? option[load_detect_key] : true
        auto_load_whitelist = option.has_key?(auto_load_whitelist_key)?option[auto_load_whitelist_key] : {}
        is_release =   option.has_key?(is_release_key)?option[is_release_key] : false
        @global_note =  PM::GlobalNote.new(load_value, update_value,detect_value,auto_load_whitelist, is_release)
        @global_note.use_service_local = option.has_key?(use_service_local_key)?option[use_service_local_key] : false
      else
        raise ArgumentError, "[cocoapods-byte-panglem][error] `#{option.inspect}`, should be a boolean or hash."
      end
      @global_note
    end

    def get_global_note
      @global_note
    end

    def get_target(label)
      @target_info ||= {}
      @target_info[label] ||= Target.new(label)
    end

    def is_release()
      @global_note.is_release
    end

    def use_service_local()
      @global_note.use_service_local
    end

    def to_hash
      hash = {}
      hash["IS_LOAD_PLUGIN"] = @is_load_plugin
      hash["PLUGIN_VERSION"] = @plugin_version
      hash["SDK_ORIGINAL_VERSION"] = @sdk_original_version
      hash["RELY_ORIGINAL_VERSION"] = @rely_original_version
      hash["SDK_TARGET_VERSION"] = @sdk_target_version
      hash["RELY_TARGET_VERSION"] = @rely_target_version
      hash["ADAPTER_LIST"] = @adapter_list
      checksum = Digest::SHA1.hexdigest(hash.inspect)
      checksum = checksum.encode('UTF-8') if checksum.respond_to?(:encode)
      hash["RECODER_CHECKSUM"] = checksum
      hash
    end
  end

  # 对应cocoapods 的Specification
  #
  class SpecificationInfo
    @@possibilities = {}
    def self.update(name = '', possibilities)
        if name.length > 0
            @@possibilities[name] ||= []
            @@possibilities[name] = @@possibilities[name] | possibilities
        end
    end

    def self.get_info()
        @@possibilities
    end

    def self.get_a_specfication(name, version)
      result =  @@possibilities[name].find { |specification|
        specification.version.version == version
      }
      result
    end

    def self.get_specfication(response_data ={}, original_sdk_spec)

      ##  这里需要获取到所有需要获取SDK期望版本下 所有subspec的specfication集合.
      ## 1. 获取到期望sdk的版本号 和 基础库的版本号
      ## 2. 计算出所有需要的subspec的名称
      ## 3. 计算出升级时需要替换的所有的specfication
      info_r = get_info
      target_sdk_version = response_data["data"]["pangle_sdk_version"]
      if target_sdk_version == nil || target_sdk_version.length == 0
        ## 兜底, 赋值为当前版本
        target_sdk_version = original_sdk_spec.spec.version.version
      end
      sdk_name = PM::BuildConfig.mediation_name
      rely_name = PM::BuildConfig.rely_name
      result = UpdateResut.new()
      result.sdk_name = sdk_name
      result.rely_name = rely_name
      target_sdk_root_spec = nil
      target_sdk_spec_list = info_r[sdk_name].select do |spec|
        target_sdk_root_spec = spec if spec.name == sdk_name && spec.version.version == target_sdk_version
        Pod::Specification.root_name(spec.name) == sdk_name && spec.version.version == target_sdk_version
      end
      if target_sdk_root_spec == nil
        raise "[cocoapods-byte-panglem][error] pangle sdk version:#{target_sdk_version} not found, please try use `pod install --repo-update`"
      end
      if target_sdk_root_spec.version.version != original_sdk_spec.spec.version.version

        result.is_sdk_update = true
        result.sdk_list = target_sdk_spec_list
        result.sdk_original_version = original_sdk_spec.spec.version.version
        result.sdk_target_version = target_sdk_root_spec.version.version
        PM::Recorder.instance.sdk_original_version = result.sdk_original_version
        PM::Recorder.instance.sdk_target_version = result.sdk_target_version
        target_rely_version = target_sdk_root_spec.get_rely_version
        original_rely_version = original_sdk_spec.spec.get_rely_version
        # target_rely_version = "0.2.0.0"
        if target_rely_version != original_rely_version
          target_rely_spec_list = info_r[rely_name].select do |spec|
            Pod::Specification.root_name(spec.name) == rely_name && spec.version.version == target_rely_version
          end
          result.is_rely_update = true
          result.rely_list = target_rely_spec_list
          result.rely_original_version = original_rely_version
          result.rely_target_version = target_rely_version
          PM::Recorder.instance.rely_original_version = result.rely_original_version
          PM::Recorder.instance.rely_target_version = result.rely_target_version
        end
      end
      result
    end
  end
end