class T::Private::Methods::DeclBuilder

def abstract(&blk)
  check_live!
  case decl.mode
  when Modes.standard
    decl.mode = Modes.abstract
  when Modes.abstract
    raise BuilderError.new(".abstract cannot be repeated in a single signature")
  else
    raise BuilderError.new("`.abstract` cannot be combined with `.override` or `.overridable`.")
  end
  check_sig_block_is_unset!
  if blk
    T::Private::DeclState.current.active_declaration.blk = blk
  end
  self
end

def bind(type)
  check_live!
  check_running_inside_block!(__method__)
  if !decl.bind.equal?(ARG_NOT_PROVIDED)
    raise BuilderError.new("You can't call .bind multiple times in a signature.")
  end
  decl.bind = type
  self
end

def check_live!
l.finalized
e BuilderError.new("You can't modify a signature declaration after it has been used.")

def check_running_inside_block!(method_name)
 @inside_sig_block || decl.mod == T::Private::Methods::PROC_TYPE
e BuilderError.new(
an't invoke #{method_name} outside of a signature declaration block"

def check_sig_block_is_unset!
Private::DeclState.current.active_declaration&.blk
e BuilderError.new(
annot add more signature statements after the declaration block."

def checked(level)
  check_live!
  check_running_inside_block!(__method__)
  if !decl.checked.equal?(ARG_NOT_PROVIDED)
    raise BuilderError.new("You can't call .checked multiple times in a signature.")
  end
  if (level == :never || level == :compiled) && !decl.on_failure.equal?(ARG_NOT_PROVIDED)
    raise BuilderError.new("You can't use .checked(:#{level}) with .on_failure because .on_failure will have no effect.")
  end
  if !T::Private::RuntimeLevels::LEVELS.include?(level)
    raise BuilderError.new("Invalid `checked` level '#{level}'. Use one of: #{T::Private::RuntimeLevels::LEVELS}.")
  end
  decl.checked = level
  self
end

def final(&blk)
  check_live!
  if !decl.final.equal?(ARG_NOT_PROVIDED)
    raise BuilderError.new("You can't call .final multiple times in a signature.")
  end
  if @inside_sig_block
    raise BuilderError.new(
      "Unlike other sig annotations, the `final` annotation must remain outside the sig block, " \
      "using either `sig(:final) {...}` or `sig.final {...}`, not `sig {final. ...}"
    )
  end
  raise BuilderError.new(".final cannot be repeated in a single signature") if final?
  decl.final = true
  check_sig_block_is_unset!
  if blk
    T::Private::DeclState.current.active_declaration.blk = blk
  end
  self
end

def final?
  !decl.final.equal?(ARG_NOT_PROVIDED) && decl.final
end

def finalize!
  check_live!
  if decl.returns.equal?(ARG_NOT_PROVIDED)
    raise BuilderError.new("You must provide a return type; use the `.returns` or `.void` builder methods.")
  end
  if decl.bind.equal?(ARG_NOT_PROVIDED)
    decl.bind = nil
  end
  if decl.checked.equal?(ARG_NOT_PROVIDED)
    default_checked_level = T::Private::RuntimeLevels.default_checked_level
    if (default_checked_level == :never || default_checked_level == :compiled) && !decl.on_failure.equal?(ARG_NOT_PROVIDED)
      raise BuilderError.new("To use .on_failure you must additionally call .checked(:tests) or .checked(:always), otherwise, the .on_failure has no effect.")
    end
    decl.checked = default_checked_level
  end
  if decl.on_failure.equal?(ARG_NOT_PROVIDED)
    decl.on_failure = nil
  end
  if decl.params.equal?(ARG_NOT_PROVIDED)
    decl.params = {}
  end
  if decl.type_parameters.equal?(ARG_NOT_PROVIDED)
    decl.type_parameters = {}
  end
  decl.finalized = true
  self
end

def initialize(mod, raw)
  # TODO RUBYPLAT-1278 - with ruby 2.5, use kwargs here
  @decl = Declaration.new(
    mod,
    ARG_NOT_PROVIDED, # params
    ARG_NOT_PROVIDED, # returns
    ARG_NOT_PROVIDED, # bind
    Modes.standard, # mode
    ARG_NOT_PROVIDED, # checked
    false, # finalized
    ARG_NOT_PROVIDED, # on_failure
    nil, # override_allow_incompatible
    ARG_NOT_PROVIDED, # type_parameters
    raw,
    ARG_NOT_PROVIDED, # final
  )
  @inside_sig_block = false
end

def on_failure(*args)
  check_live!
  check_running_inside_block!(__method__)
  if !decl.on_failure.equal?(ARG_NOT_PROVIDED)
    raise BuilderError.new("You can't call .on_failure multiple times in a signature.")
  end
  if decl.checked == :never || decl.checked == :compiled
    raise BuilderError.new("You can't use .on_failure with .checked(:#{decl.checked}) because .on_failure will have no effect.")
  end
  decl.on_failure = args
  self
end

def overridable(&blk)
  check_live!
  case decl.mode
  when Modes.abstract
    raise BuilderError.new("`.overridable` cannot be combined with `.#{decl.mode}`")
  when Modes.override
    decl.mode = Modes.overridable_override
  when Modes.standard
    decl.mode = Modes.overridable
  when Modes.overridable, Modes.overridable_override
    raise BuilderError.new(".overridable cannot be repeated in a single signature")
  end
  check_sig_block_is_unset!
  if blk
    T::Private::DeclState.current.active_declaration.blk = blk
  end
  self
end

def override(allow_incompatible: false, &blk)
  check_live!
  case decl.mode
  when Modes.standard
    decl.mode = Modes.override
    decl.override_allow_incompatible = allow_incompatible
  when Modes.override, Modes.overridable_override
    raise BuilderError.new(".override cannot be repeated in a single signature")
  when Modes.overridable
    decl.mode = Modes.overridable_override
  else
    raise BuilderError.new("`.override` cannot be combined with `.abstract`.")
  end
  check_sig_block_is_unset!
  if blk
    T::Private::DeclState.current.active_declaration.blk = blk
  end
  self
end

def params(**params)
  check_live!
  check_running_inside_block!(__method__)
  if !decl.params.equal?(ARG_NOT_PROVIDED)
    raise BuilderError.new("You can't call .params twice")
  end
  if params.empty?
    raise BuilderError.new("params expects keyword arguments")
  end
  decl.params = params
  self
end

def returns(type)
  check_live!
  check_running_inside_block!(__method__)
  if decl.returns.is_a?(T::Private::Types::Void)
    raise BuilderError.new("You can't call .returns after calling .void.")
  end
  if !decl.returns.equal?(ARG_NOT_PROVIDED)
    raise BuilderError.new("You can't call .returns multiple times in a signature.")
  end
  decl.returns = type
  self
end

def run!(&block)
  @inside_sig_block = true
  instance_exec(&block)
  finalize!
  self
end

def type_parameters(*names)
  check_live!
  check_running_inside_block!(__method__)
  names.each do |name|
    raise BuilderError.new("not a symbol: #{name}") unless name.is_a?(Symbol)
  end
  if !decl.type_parameters.equal?(ARG_NOT_PROVIDED)
    raise BuilderError.new("You can't call .type_parameters multiple times in a signature.")
  end
  decl.type_parameters = names
  self
end

def void
  check_live!
  check_running_inside_block!(__method__)
  if !decl.returns.equal?(ARG_NOT_PROVIDED)
    raise BuilderError.new("You can't call .void after calling .returns.")
  end
  decl.returns = T::Private::Types::Void.new
  self
end