# Copyright (c) 2016, 2021, Oracle and/or its affiliates.  All rights reserved.
# This software is dual-licensed to you under the Universal Permissive License (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl or Apache License 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose either license.

require 'date'

# rubocop:disable Lint/UnneededCopDisableDirective, Metrics/LineLength
module OCI
  # Upsert LogAnalytics Label Details
  class LogAnalytics::Models::UpsertLogAnalyticsLabelDetails
    PRIORITY_ENUM = [
      PRIORITY_NONE = 'NONE'.freeze,
      PRIORITY_LOW = 'LOW'.freeze,
      PRIORITY_MEDIUM = 'MEDIUM'.freeze,
      PRIORITY_HIGH = 'HIGH'.freeze
    ].freeze

    TYPE_ENUM = [
      TYPE_INFO = 'INFO'.freeze,
      TYPE_PROBLEM = 'PROBLEM'.freeze
    ].freeze

    # The alias list.
    # @return [Array<OCI::LogAnalytics::Models::LogAnalyticsLabelAlias>]
    attr_accessor :aliases

    # suggest type
    # @return [Integer]
    attr_accessor :suggest_type

    # The label description.
    # @return [String]
    attr_accessor :description

    # The label display name.
    # @return [String]
    attr_accessor :display_name

    # The edit version.
    # @return [Integer]
    attr_accessor :edit_version

    # The label impact.
    # @return [String]
    attr_accessor :impact

    # The system flag.  A value of false denotes a custom, or user
    # defined label.  A value of true denotes a built in label.
    #
    # @return [BOOLEAN]
    attr_accessor :is_system

    # The label name.
    # @return [String]
    attr_accessor :name

    # The label priority. Valid values are (NONE, LOW, HIGH). NONE is default.
    # @return [String]
    attr_reader :priority

    # The label recommendation.
    # @return [String]
    attr_accessor :recommendation

    # The label type. Valid values are (INFO, PROBLEM). INFO is default.
    # @return [String]
    attr_reader :type

    # Attribute mapping from ruby-style variable name to JSON key.
    def self.attribute_map
      {
        # rubocop:disable Style/SymbolLiteral
        'aliases': :'aliases',
        'suggest_type': :'suggestType',
        'description': :'description',
        'display_name': :'displayName',
        'edit_version': :'editVersion',
        'impact': :'impact',
        'is_system': :'isSystem',
        'name': :'name',
        'priority': :'priority',
        'recommendation': :'recommendation',
        'type': :'type'
        # rubocop:enable Style/SymbolLiteral
      }
    end

    # Attribute type mapping.
    def self.swagger_types
      {
        # rubocop:disable Style/SymbolLiteral
        'aliases': :'Array<OCI::LogAnalytics::Models::LogAnalyticsLabelAlias>',
        'suggest_type': :'Integer',
        'description': :'String',
        'display_name': :'String',
        'edit_version': :'Integer',
        'impact': :'String',
        'is_system': :'BOOLEAN',
        'name': :'String',
        'priority': :'String',
        'recommendation': :'String',
        'type': :'String'
        # rubocop:enable Style/SymbolLiteral
      }
    end

    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity
    # rubocop:disable Metrics/MethodLength, Layout/EmptyLines, Style/SymbolLiteral


    # Initializes the object
    # @param [Hash] attributes Model attributes in the form of hash
    # @option attributes [Array<OCI::LogAnalytics::Models::LogAnalyticsLabelAlias>] :aliases The value to assign to the {#aliases} property
    # @option attributes [Integer] :suggest_type The value to assign to the {#suggest_type} property
    # @option attributes [String] :description The value to assign to the {#description} property
    # @option attributes [String] :display_name The value to assign to the {#display_name} property
    # @option attributes [Integer] :edit_version The value to assign to the {#edit_version} property
    # @option attributes [String] :impact The value to assign to the {#impact} property
    # @option attributes [BOOLEAN] :is_system The value to assign to the {#is_system} property
    # @option attributes [String] :name The value to assign to the {#name} property
    # @option attributes [String] :priority The value to assign to the {#priority} property
    # @option attributes [String] :recommendation The value to assign to the {#recommendation} property
    # @option attributes [String] :type The value to assign to the {#type} property
    def initialize(attributes = {})
      return unless attributes.is_a?(Hash)

      # convert string to symbol for hash key
      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }

      self.aliases = attributes[:'aliases'] if attributes[:'aliases']

      self.suggest_type = attributes[:'suggestType'] if attributes[:'suggestType']

      raise 'You cannot provide both :suggestType and :suggest_type' if attributes.key?(:'suggestType') && attributes.key?(:'suggest_type')

      self.suggest_type = attributes[:'suggest_type'] if attributes[:'suggest_type']

      self.description = attributes[:'description'] if attributes[:'description']

      self.display_name = attributes[:'displayName'] if attributes[:'displayName']

      raise 'You cannot provide both :displayName and :display_name' if attributes.key?(:'displayName') && attributes.key?(:'display_name')

      self.display_name = attributes[:'display_name'] if attributes[:'display_name']

      self.edit_version = attributes[:'editVersion'] if attributes[:'editVersion']

      raise 'You cannot provide both :editVersion and :edit_version' if attributes.key?(:'editVersion') && attributes.key?(:'edit_version')

      self.edit_version = attributes[:'edit_version'] if attributes[:'edit_version']

      self.impact = attributes[:'impact'] if attributes[:'impact']

      self.is_system = attributes[:'isSystem'] unless attributes[:'isSystem'].nil?

      raise 'You cannot provide both :isSystem and :is_system' if attributes.key?(:'isSystem') && attributes.key?(:'is_system')

      self.is_system = attributes[:'is_system'] unless attributes[:'is_system'].nil?

      self.name = attributes[:'name'] if attributes[:'name']

      self.priority = attributes[:'priority'] if attributes[:'priority']
      self.priority = "NONE" if priority.nil? && !attributes.key?(:'priority') # rubocop:disable Style/StringLiterals

      self.recommendation = attributes[:'recommendation'] if attributes[:'recommendation']

      self.type = attributes[:'type'] if attributes[:'type']
      self.type = "INFO" if type.nil? && !attributes.key?(:'type') # rubocop:disable Style/StringLiterals
    end
    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity
    # rubocop:enable Metrics/MethodLength, Layout/EmptyLines, Style/SymbolLiteral

    # Custom attribute writer method checking allowed values (enum).
    # @param [Object] priority Object to be assigned
    def priority=(priority)
      raise "Invalid value for 'priority': this must be one of the values in PRIORITY_ENUM." if priority && !PRIORITY_ENUM.include?(priority)

      @priority = priority
    end

    # Custom attribute writer method checking allowed values (enum).
    # @param [Object] type Object to be assigned
    def type=(type)
      raise "Invalid value for 'type': this must be one of the values in TYPE_ENUM." if type && !TYPE_ENUM.include?(type)

      @type = type
    end

    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity, Layout/EmptyLines


    # Checks equality by comparing each attribute.
    # @param [Object] other the other object to be compared
    def ==(other)
      return true if equal?(other)

      self.class == other.class &&
        aliases == other.aliases &&
        suggest_type == other.suggest_type &&
        description == other.description &&
        display_name == other.display_name &&
        edit_version == other.edit_version &&
        impact == other.impact &&
        is_system == other.is_system &&
        name == other.name &&
        priority == other.priority &&
        recommendation == other.recommendation &&
        type == other.type
    end
    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity, Layout/EmptyLines

    # @see the `==` method
    # @param [Object] other the other object to be compared
    def eql?(other)
      self == other
    end

    # rubocop:disable Metrics/AbcSize, Layout/EmptyLines


    # Calculates hash code according to all attributes.
    # @return [Fixnum] Hash code
    def hash
      [aliases, suggest_type, description, display_name, edit_version, impact, is_system, name, priority, recommendation, type].hash
    end
    # rubocop:enable Metrics/AbcSize, Layout/EmptyLines

    # rubocop:disable Metrics/AbcSize, Layout/EmptyLines


    # Builds the object from hash
    # @param [Hash] attributes Model attributes in the form of hash
    # @return [Object] Returns the model itself
    def build_from_hash(attributes)
      return nil unless attributes.is_a?(Hash)

      self.class.swagger_types.each_pair do |key, type|
        if type =~ /^Array<(.*)>/i
          # check to ensure the input is an array given that the the attribute
          # is documented as an array but the input is not
          if attributes[self.class.attribute_map[key]].is_a?(Array)
            public_method("#{key}=").call(
              attributes[self.class.attribute_map[key]]
                .map { |v| OCI::Internal::Util.convert_to_type(Regexp.last_match(1), v) }
            )
          end
        elsif !attributes[self.class.attribute_map[key]].nil?
          public_method("#{key}=").call(
            OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]])
          )
        end
        # or else data not found in attributes(hash), not an issue as the data can be optional
      end

      self
    end
    # rubocop:enable Metrics/AbcSize, Layout/EmptyLines

    # Returns the string representation of the object
    # @return [String] String presentation of the object
    def to_s
      to_hash.to_s
    end

    # Returns the object in the form of hash
    # @return [Hash] Returns the object in the form of hash
    def to_hash
      hash = {}
      self.class.attribute_map.each_pair do |attr, param|
        value = public_method(attr).call
        next if value.nil? && !instance_variable_defined?("@#{attr}")

        hash[param] = _to_hash(value)
      end
      hash
    end

    private

    # Outputs non-array value in the form of hash
    # For object, use to_hash. Otherwise, just return the value
    # @param [Object] value Any valid value
    # @return [Hash] Returns the value in the form of hash
    def _to_hash(value)
      if value.is_a?(Array)
        value.compact.map { |v| _to_hash(v) }
      elsif value.is_a?(Hash)
        {}.tap do |hash|
          value.each { |k, v| hash[k] = _to_hash(v) }
        end
      elsif value.respond_to? :to_hash
        value.to_hash
      else
        value
      end
    end
  end
end
# rubocop:enable Lint/UnneededCopDisableDirective, Metrics/LineLength
