ViewModelProvider(this(액티비티)).get(액티비티 뷰모델명::class.java)

private val activityViewModel by lazy {
        //Fragment에서 ViewModelProvider을 생성 할 때 Fragment 를 넣는게 아니라 Activity 가 들어 가야 한다.  
        ViewModelProvider(requireActivity()).get(액티비티 뷰모델명::class.java)
}

dependencies {
    //현재 최신버전인 1.0.2 버전으로 사용하였다.
    implementation "org.koin:koin-android:1.0.2" 
}

class TestApplication : Application() { //Application 클래스에서 모듈과 startKoin을 호출 해준다.

    private val goodsModule = module {
        factory { GoodsData() } //상품데이터 생성
        single { GoodsServiceImpl(get()) as GoodsService } 
        //GoodsService는 싱글톤으로 생성 되고  get() 은 컴포넌트내에 알맞은 의존성 주입을 해준다.
        //get() 은 GoodsData 라고 생각 하면 된다.
        factory {
            //FactoryData 가 생성 될 때마다 변경되는 값을 넣기 위해 현재시간(Long 타입)을 사용
            return@factory FactoryData(Calendar.getInstance().timeInMillis)
        }
    }

    override fun onCreate() {
        super.onCreate()
        startKoin(this, listOf(goodsModule)) //코인 시작!! listOf 에는 다른 모듈도 정의 한다면 뒤에 더 붙여서 사용
    }

}

//FactoryData 데이터 클래스
data class FactoryData(val timeInMillis: Long = 0L)

//GoodsData 데이터 클래스
data class GoodsData(var name : String = "청바지", var price : Long = 30000)

interface GoodsService {
    fun getGoodsInfo(): String
}

class GoodsServiceImpl(private val goodsData: GoodsData) : GoodsService {

    override fun getGoodsInfo(): String {
        //기본적으로 생성 되는 goodsData 정보는 상품명 청바지 , 가격 30000
        return "상품명 : " + goodsData.name + "  가격 : " + goodsData.price
    }
}

class MainActivity : AppCompatActivity() {
    private val goodsService: GoodsService by inject()  //by inject() 를 사용해서 GoodsService 주입
    private val goodsData: GoodsData by inject() //by inject() 를 사용해서 GoodsData 주입
    private val factoryData: FactoryData by inject() //by inject() 를 사용해서 FactoryData 주입

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
    }

}

class ProxyPattern {
    @Test
    fun test() {
        ImageProxy().showIcon()
    }
}

interface Icon {
    fun showIcon()
}

class ImageIcon : Icon {

    override fun showIcon() {
        download()
        println("ImageIcon 그림")
    }

    private fun download() {
        println("ImageIcon 다운로드")
    }

}

class ImageProxy : Icon {
    var imageIcon: ImageIcon? = null

    override fun showIcon() {
        println("ImageProxy 그림")
        imageIcon = ImageIcon()
        imageIcon?.showIcon()
    }
}

class StatePattern {
    @Test
    fun test() {
        val stateContext = StateContext()
        stateContext.state = BadState(stateContext)
        stateContext.clear()
        stateContext.rain()
        stateContext.vacation()
        stateContext.rain()
    }

    interface State {
        fun rain()
        fun clear()
        fun vacation()
    }

    class GoodState(private val stateContext: StateContext) : State {
        override fun rain() {
            println("비가와서 기분 좋음에서 보통으로")
            stateContext.state = stateContext.normalState
        }
        override fun clear() {
            println("날씨 맑아서 기분 좋지만 최상의 상태")
        }
        override fun vacation() {
            println("휴가다~~! ^^ 하지만 최상의 상태")
        }
    }

    class NormalState(private val stateContext: StateContext) : State {
        override fun rain() {
            println("비가와서 기분 보통에서 나쁨으로")
            stateContext.state = stateContext.badState
        }
        override fun clear() {
            println("날씨 맑아서 기분 보통에서 좋음 변경")
            stateContext.state = stateContext.goodState
        }
        override fun vacation() {
            println("휴가다~~! ^^ 기분 보통에서 좋음 변경")
            stateContext.state = stateContext.goodState
        }
    }

    class BadState(private val stateContext: StateContext) : State {
        override fun rain() {
            println("비가 오지만 이보다 더 안좋을 수 없다.")
        }
        override fun clear() {
            println("날씨 맑아서 기분 안좋음에서 보통으로 변경")
            stateContext.state = stateContext.normalState
        }
        override fun vacation() {
            println("휴가다~~! ^^ 기분 안좋음에서 좋음으로 두단계 업!!")
            stateContext.state = stateContext.goodState
        }
    }


    class StateContext {
        var state: State? = null
        var goodState = GoodState(this)
        var normalState = NormalState(this)
        var badState = BadState(this)
        fun rain() {
            state?.rain()
        }
        fun clear() {
            state?.clear()
        }
        fun vacation() {
            state?.vacation()
        }
    }
}

class CompositePattern {
    @Test
    fun test() {
        val allMenus = Menu("전체메뉴")

        val breakfastMenu = Menu("아침메뉴").apply {
            menuComponents.apply {
                add(MenuItem("토스트", 3000))
                add(MenuItem("삼겹살", 10000))
                add(MenuItem("김밥", 2500))
            }
        }

        val lunchMenu = Menu("점심메뉴").apply {
            menuComponents.apply {
                add(MenuItem("ㅄㅎㄱ", 10000))
                add(MenuItem("ㅍㅇㅈ", 3500))
            }
        }

        allMenus.menuComponents.apply {
            add(breakfastMenu)
            add(lunchMenu)
        }

        allMenus.print()

    }

    //Component
    abstract class MenuComponent {
        abstract fun print()
    }

    //Leaf
    class MenuItem(private val name: String, private val price: Int) : MenuComponent() {
        override fun print() {
            println("name : $name , price : $price")
        }
    }

    //Composite
    class Menu(private val name: String) : MenuComponent() {
        val menuComponents = arrayListOf<MenuComponent>()

        override fun print() {
            println("name : $name")
            val iterator = menuComponents.iterator()
            while (iterator.hasNext()) {
                val menuComponent = iterator.next()
                menuComponent.print()
            }
        }
    }
}