class Travis::Client::Entity

def self.aka(*names)
  names.each { |n| MAP[n.to_s] = self }
end

def self.attributes(*list)
  @attributes ||= []
  list.each do |name|
    name = name.to_s
    raise "can't call an attribute id" if name == 'id'
    @attributes << name
    define_method(name) { load_attribute(name) }
    define_method("#{name}=") { |value| set_attribute(name, value) }
    define_method("#{name}?") { !!send(name) }
  end
  @attributes
end

def self.base_path
  many
end

def self.cast_id(id)
  Integer(id)
end

def self.has(*list)
  list.each do |name|
    relations << name
    define_method(name) { relation(name.to_s) }
  end
end

def self.has_singleton(*list)
  list.each do |name|
    alias_method :"#{name}_id", :id unless method_defined? :"#{name}_id"
    has(name)
  end
end

def self.id?(object)
  object.is_a? Integer
end

def self.id_field(key = nil)
  @id_field = key.to_s if key
  @id_field || superclass.id_field
end

def self.inspect_info(name)
  alias_method(:inspect_info, name)
  private(:inspect_info)
end

def self.many(key = nil)
  MAP[key.to_s] = self if key
  @many ||= key.to_s
end

def self.one(key = nil)
  MAP[key.to_s] = self if key
  @one ||= key.to_s
end

def self.preloadable
  def self.preloadable?
    true
  end
end

def self.preloadable?
  true
end

def self.preloadable?
  false
end

def self.relations
  @relations ||= []
end

def self.subclass_for(key)
  MAP.fetch(key.to_s)
end

def self.subclasses
  MAP.values.uniq
end

def self.time(*list)
  list.each do |name|
    define_method("#{name}=") { |value| set_attribute(name, time(value)) }
  end
end

def self.weak?
  false
end

def [](key)
  key = key.to_s
  send(key) if include? key
end

def []=(key, value)
  key = key.to_s
  send("#{key}=", value) if include? key
end

def attribute_names
  self.class.attributes
end

def cancelable?
  false
end

def complete?
  attribute_names.all? { |key| attributes.include? key }
end

def include?(key)
  attributes.include? key or attribute_names.include? key.to_s
end

def initialize(session, id)
  raise Travis::Client::Error, '%p is not a valid id' % id unless self.class.id? id
  @attributes = {}
  @session    = session
  @id         = self.class.cast_id(id) if id
end

def inspect
  klass = self.class
  klass = curry if curry&.name && curry.to_s.size < klass.to_s.size
  "#<#{klass}: #{inspect_info}>"
end

def inspect_info
  id
end

def load
  session.reload(self) unless complete?
end

def load_attribute(name)
  session.reload(self) if missing? name
  attributes[name.to_s]
end

def missing?(key)
  return false unless include? key
  !attributes.include?(key.to_s)
end

def relation(name)
  name   = name.to_s
  entity = Entity.subclass_for(name)
  if entity.many == name
    Array(send("#{entity.one}_ids")).map do |id|
      session.find_one(entity, id)
    end
  else
    id = send("#{name}_id")
    session.find_one(entity, id) unless id.nil?
  end
end

def relations
  self.class.relations.map { |r| public_send(r) }.flatten(1)
end

def reload
  relations.each { |e| session.reset(e) }
  session.reset(self)
end

def restartable?
  false
end

def set_attribute(name, value)
  attributes[name.to_s] = value
end

def time(value)
  if value.respond_to? :to_time
    value.to_time
  elsif value.is_a? Time
    value
  elsif value.respond_to? :new_offset
    d = value.new_offset 0
    t = Time.utc d.year, d.mon, d.mday, d.hour, d.min, d.sec + d.sec_fraction
    t.getlocal
  elsif value.respond_to? :mday
    Time.local(value.year, value.mon, value.mday)
  elsif value.is_a? Numeric
    Time.at value
  elsif value.nil? || value.empty?
    nil
  else
    Time.parse value.to_s
  end
rescue ArgumentError => e
  raise e
rescue Exception
  raise ArgumentError, "unable to convert #{value.inspect} to a Time object"
end

def to_h
  Hash[attribute_names.map { |n| [n, self[n]] }]
end

def update_attributes(data)
  data.each_pair do |key, value|
    self[key] = value
  end
end