class Instance

def [](kind)
  @resource_classes[kind] ||= begin
    # Custom schemas win over built-in definitions.
    custom = find_custom_entry(kind)
    if custom
      build_resource_class(custom[:schema], custom[:defaults])
    else
      entry = find_gvk_entry(kind)

      if entry.nil?
        raise "No resource schema found for #{kind}!" \
          "\nUse #list_resources to see available kinds for v#{version}."
      end

      ref_schema = schemer.ref("#/definitions/#{entry[:definition_key]}")
      build_resource_class(ref_schema, entry[:defaults].freeze)
    end
  end
end

def list_resources
  (gvk_index.keys + Schema.custom_schemas.keys).uniq.sort
end

def sub_spec(name)
  @sub_spec_classes[name] ||= begin
    definition_key = find_definition_key(name)

    if definition_key.nil?
      raise "No definition found for #{name}!" \
        "\nUse #list_definitions to see available definitions for v#{version}."
    end

    ref_schema = schemer.ref("#/definitions/#{definition_key}")
    build_sub_spec_class(ref_schema, name)
  end
end

def list_definitions
  schemer.value.fetch("definitions", {}).keys
    .map { |k| k.split(".").last }
    .uniq.sort
end

def schemer
  self.class.schemers[@version] ||= begin
    path = File.join(SCHEMAS_DIR, "v#{version}.json")

    unless File.exist?(path)
      raise UnknownVersionError,
        "\nNo schema file found at #{path}." \
        "\nUse `Kube::Schema.schema_versions` to get a list."
    end

    schema = JSON.parse(File.read(path))

    # Merge extra definition files (*-definitions.json) into the
    # base schema so CRD and aggregated-API types (e.g. loft,
    # gateway-api) are available alongside built-in k8s types.
    Dir.glob(File.join(SCHEMAS_DIR, "*-definitions.json")).each do |defs_path|
      extra = JSON.parse(File.read(defs_path))
      schema["definitions"] ||= {}
      schema["definitions"].merge!(extra)
    end

    # Kubernetes OpenAPI v2 defines IntOrString as "type": "string"
    # with "format": "int-or-string". This is a limitation of
    # OpenAPI v2 which cannot express union types. Patch the
    # definition so JSONSchemer accepts both integers and strings.
    if (int_or_str = schema.dig("definitions", "io.k8s.apimachinery.pkg.util.intstr.IntOrString"))
      int_or_str["type"] = ["string", "integer"]
    end

    JSONSchemer.schema(schema)
  end
end

def gvk_index
  @gvk_index ||= begin
    index = {}

    schemer.value.fetch("definitions", {}).each do |key, definition|
      gvks = definition["x-kubernetes-group-version-kind"]
      next unless gvks

      gvks.each do |gvk|
        group = gvk["group"].to_s
        version = gvk["version"]
        kind = gvk["kind"]
        api_version = group.empty? ? version : "#{group}/#{version}"

        index[kind] = {
          definition_key: key,
          group: group,
          version: version,
          kind: kind,
          defaults: {
            "apiVersion" => api_version,
            "kind" => kind
          }
        }
      end
    end

    index
  end
end

def find_gvk_entry(kind)
  return gvk_index[kind] if gvk_index.key?(kind)

  gvk_index.each do |k, v|
    return v if k.downcase == kind.downcase
  end

  nil
end

def find_custom_entry(kind)
  registry = Schema.custom_schemas
  return registry[kind] if registry.key?(kind)

  registry.each do |k, v|
    return v if k.downcase == kind.downcase
  end

  nil
end

def build_resource_class(schema_instance, defaults)
  Class.new(::Kube::Schema::Resource) do
    @schema = schema_instance
    @defaults = defaults
    @schema_properties = @schema.value["properties"].keys.map(&:to_sym)

    def self.schema
      @schema || superclass.schema
    end

    def self.defaults
      @defaults || superclass.defaults
    end

    def self.schema_properties
      @schema_properties || superclass.schema_properties
    end

    schema_instance.value["properties"].keys.then do |properties|
      properties.each do |prop|
        define_method(prop.to_sym) { @data[prop.to_sym] }
      end
    end
  end
end

def find_definition_key(name)
  definitions = schemer.value.fetch("definitions", {})

  # Exact full-key match
  return name if definitions.key?(name)

  # Short-name matches (last segment after final ".")
  candidates = definitions.keys.select { |k| k.split(".").last == name }
  return nil if candidates.empty?
  return candidates.first if candidates.size == 1

  # Disambiguation: prefer stable versions, then beta, then alpha
  candidates.min_by { |k|
    version_segment = k.split(".")[-2].to_s
    case version_segment
    when /\Av\d+\z/ then [0, version_segment]
    when /beta/      then [1, version_segment]
    when /alpha/     then [2, version_segment]
    else                  [3, version_segment]
    end
  }
end

def build_sub_spec_class(schema_instance, definition_name)
  Class.new(::Kube::Schema::SubSpec) do
    @schema = schema_instance
    @definition_name = definition_name
    @schema_properties = @schema.value.fetch("properties", {}).keys.map(&:to_sym)

    def self.schema
      @schema || superclass.schema
    end

    def self.definition_name
      @definition_name || superclass.definition_name
    end

    def self.schema_properties
      @schema_properties || superclass.schema_properties
    end

    schema_instance.value.fetch("properties", {}).keys.each do |prop|
      define_method(prop.to_sym) { @data[prop.to_sym] }
    end
  end
end

def clear_resource_cache!
  @resource_classes.clear
end