module OnebusawaySDK::Internal::Type::Converter

def coerce(value, state:) = (raise NotImplementedError)

def coerce(target, value, state: OnebusawaySDK::Internal::Type::Converter.new_coerce_state)
  # rubocop:disable Metrics/BlockNesting
  exactness = state.fetch(:exactness)
  case target
  in OnebusawaySDK::Internal::Type::Converter
    return target.coerce(value, state: state)
  in Class
    if value.is_a?(target)
      exactness[:yes] += 1
      return value
    end
    case target
    in -> { _1 <= NilClass }
      exactness[value.nil? ? :yes : :maybe] += 1
      return nil
    in -> { _1 <= Integer }
      case value
      in Integer
        exactness[:yes] += 1
        return value
      else
        Kernel.then do
          return Integer(value).tap { exactness[:maybe] += 1 }
        rescue ArgumentError, TypeError => e
          state[:error] = e
        end
      end
    in -> { _1 <= Float }
      if value.is_a?(Numeric)
        exactness[:yes] += 1
        return Float(value)
      else
        Kernel.then do
          return Float(value).tap { exactness[:maybe] += 1 }
        rescue ArgumentError, TypeError => e
          state[:error] = e
        end
      end
    in -> { _1 <= String }
      case value
      in String | Symbol | Numeric
        exactness[value.is_a?(Numeric) ? :maybe : :yes] += 1
        return value.to_s
      in StringIO
        exactness[:yes] += 1
        return value.string
      else
        state[:error] = TypeError.new("#{value.class} can't be coerced into #{String}")
      end
    in -> { _1 <= Date || _1 <= Time }
      Kernel.then do
        return target.parse(value).tap { exactness[:yes] += 1 }
      rescue ArgumentError, TypeError => e
        state[:error] = e
      end
    in -> { _1 <= StringIO } if value.is_a?(String)
      exactness[:yes] += 1
      return StringIO.new(value.b)
    else
    end
  in Symbol
    case value
    in Symbol | String
      if value.to_sym == target
        exactness[:yes] += 1
        return target
      else
        exactness[:maybe] += 1
        return value
      end
    else
      message = "cannot convert non-matching #{value.class} into #{target.inspect}"
      state[:error] = ArgumentError.new(message)
    end
  else
  end
  exactness[:no] += 1
  value
  # rubocop:enable Metrics/BlockNesting
end

def dump(value, state:)
  case value
  in Array
    value.map { OnebusawaySDK::Internal::Type::Unknown.dump(_1, state: state) }
  in Hash
    value.transform_values { OnebusawaySDK::Internal::Type::Unknown.dump(_1, state: state) }
  in OnebusawaySDK::Internal::Type::BaseModel
    value.class.dump(value, state: state)
  in StringIO
    value.string
  in Pathname | IO
    state[:can_retry] = false if value.is_a?(IO)
    OnebusawaySDK::FilePart.new(value)
  in OnebusawaySDK::FilePart
    state[:can_retry] = false if value.content.is_a?(IO)
    value
  else
    value
  end
end

def dump(target, value, state: {can_retry: true})
  case target
  in OnebusawaySDK::Internal::Type::Converter
    target.dump(value, state: state)
  else
    OnebusawaySDK::Internal::Type::Unknown.dump(value, state: state)
  end
end

def inspect(depth: 0)
  super()
end

def inspect(target, depth:)
  case target
  in OnebusawaySDK::Internal::Type::Converter
    target.inspect(depth: depth.succ)
  else
    target.inspect
  end
end

def new_coerce_state(translate_names: true)
  {
    translate_names: translate_names,
    strictness: true,
    exactness: {yes: 0, no: 0, maybe: 0},
    error: nil,
    branched: 0
  }
end

def type_info(spec)
  case spec
  in Proc
    spec
  in Hash
    type_info(spec.slice(:const, :enum, :union).first&.last)
  in true | false
    -> { OnebusawaySDK::Internal::Type::Boolean }
  in OnebusawaySDK::Internal::Type::Converter | Class | Symbol
    -> { spec }
  in NilClass | Integer | Float
    -> { spec.class }
  end
end