describe "class", ->
  it "should make a class with constructor", ->
    class Thing
      new: =>
        @color = "blue"

    instance = Thing!

    assert.same instance, { color: "blue" }

  it "should have instance methods", ->
    class Thing
      get_color: => @color

      new: =>
        @color = "blue"

    instance = Thing!
    assert.same instance\get_color!, "blue"

  it "should have base properies from class", ->
    class Thing
      color: "blue"
      get_color: => @color

    instance = Thing!
    assert.same instance\get_color!, "blue"
    assert.same Thing.color, "blue"

  it "should inherit another class", ->
    class Base
      get_property: => @[@property]

      new: (@property) =>

    class Thing extends Base
      color: "green"

    instance = Thing "color"
    assert.same instance\get_property!, "green"


  it "should have class properties", ->
    class Base
    class Thing extends Base

    instance = Thing!

    assert.same Base.__name, "Base"
    assert.same Thing.__name, "Thing"
    assert.is_true Thing.__parent == Base

    assert.is_true instance.__class == Thing

  it "should have name when assigned", ->
    Thing = class
    assert.same Thing.__name, "Thing"

  it "should not expose class properties on instance", ->
    class Thing
      @height: 10

    Thing.color = "blue"

    instance = Thing!
    assert.same instance.color, nil
    assert.same instance.height, nil

  it "should expose new things added to __base", ->
    class Thing

    instance = Thing!
    Thing.__base.color = "green"

    assert.same instance.color, "green"

  it "should call with correct receiver", ->
    local instance

    class Thing
      is_class: => assert.is_true @ == Thing
      is_instance: => assert.is_true @ == instance

      go: =>
        @@is_class!
        @is_instance!

    instance = Thing!
    instance\go!

  it "should have class properies take precedence over base properties", ->
    class Thing
      @prop: "hello"
      prop: "world"

    assert.same "hello", Thing.prop

  describe "super", ->
    it "should call super constructor", ->
      class Base
        new: (@property) =>

      class Thing extends Base
        new: (@name) =>
          super "name"

      instance = Thing "the_thing"

      assert.same instance.property, "name"
      assert.same instance.name, "the_thing"

    it "should call super method", ->
      class Base
        _count: 111
        counter: => @_count

      class Thing extends Base
        counter: => "%08d"\format super!

      instance = Thing!
      assert.same instance\counter!, "00000111"

    it "should call other method from super", ->
      class Base
        _count: 111
        counter: =>
          @_count

      class Thing extends Base
        other_method: => super\counter!

      instance = Thing!
      assert.same instance\other_method!, 111

    it "should get super class", ->
      class Base
      class Thing extends Base
        get_super: => super

      instance = Thing!
      assert.is_true instance\get_super! == Base

    it "should get a bound method from super", ->
      class Base
        count: 1
        get_count: => @count

      class Thing extends Base
        get_count: => "this is wrong"
        get_method: => super\get_count

      instance = Thing!
      assert.same instance\get_method!!, 1

    it "class properties take precedence in super class over base", ->
      class Thing
        @prop: "hello"
        prop: "world"

      class OtherThing extends Thing

      assert.same "hello", OtherThing.prop

    it "gets value from base in super class", ->
      class Thing
        prop: "world"

      class OtherThing extends Thing
      assert.same "world", OtherThing.prop

    it "should let parent be replaced on class", ->
      class A
        @prop: "yeah"
        cool: => 1234
        plain: => "a"

      class B
        @prop: "okay"
        cool: => 9999
        plain: => "b"

      class Thing extends A
        cool: =>
          super! + 1

        get_super: =>
          super

      instance = Thing!

      assert.same "a", instance\plain!
      assert.same 1235, instance\cool!
      assert A == instance\get_super!, "expected super to be B"

      Thing.__parent = B
      setmetatable Thing.__base, B.__base

      assert.same "b", instance\plain!
      assert.same 10000, instance\cool!
      assert B == instance\get_super!, "expected super to be B"

    it "should resolve many levels of super", ->
      class One
        a: =>
          1

      class Two extends One
        a: =>
          super! + 2

      class Three extends Two
        a: =>
          super! + 3

      i = Three!

      assert.same 6, i\a!


    it "should resolve many levels of super with a gap", ->
      class One
        a: =>
          1

      class Two extends One

      class Three extends Two
        a: =>
          super! + 3

      class Four extends Three
        a: =>
          super! + 4

      i = Four!

      assert.same 8, i\a!


    it "should call correct class/instance super methods", ->
      class Base
        doit: =>
          "instance"

        @doit: =>
          "class"

      class One extends Base
        doit: => super!
        @doit: => super!

      assert.same "instance", One!\doit!
      assert.same "class", One\doit!


    it "should resolve many levels of super on class methods", ->
      class One
        @a: =>
          1

      class Two extends One

      class Three extends Two
        @a: =>
          super! + 3

      class Four extends Three
        @a: =>
          super! + 4

      assert.same 8, Four\a!

    it "super should still work when method wrapped", ->
      add_some = (opts) ->
        => opts.amount + opts[1] @

      class Base
        value: => 1

      class Sub extends Base
        value: add_some {
          amount: 12
          =>
            super! + 100
        }

      assert.same 1 + 100 + 12, Sub!\value!