conventionschedule-android/app/src/main/java/com/adlerosn/brasilfurfest/schedule/EventActivity.kt

package com.adlerosn.brasilfurfest.schedule

import android.annotation.SuppressLint
import android.content.Intent
import android.content.res.Resources
import android.graphics.Color
import android.graphics.drawable.Drawable
import android.os.Bundle
import android.provider.CalendarContract
import android.support.design.widget.Snackbar
import android.support.v4.content.ContextCompat
import android.support.v7.app.AppCompatActivity
import android.view.View
import android.view.ViewGroup
import android.view.WindowManager
import com.adlerosn.brasilfurfest.CountdownActivity
import com.adlerosn.brasilfurfest.R
import com.adlerosn.brasilfurfest.SplashActivity
import com.adlerosn.brasilfurfest.helper.*
import com.adlerosn.brasilfurfest.schedule.abstractDataTypes.managed.AttendeeConFavorite
import kotlinx.android.synthetic.main.activity_event.*
import kotlinx.android.synthetic.main.activity_event_content.*
import kotlinx.android.synthetic.main.activity_event_content_keypair.view.*
import java.text.SimpleDateFormat
import java.util.*


class EventActivity : AppCompatActivity() {

    private var fromNotification = false


    override fun onCreate(savedInstanceState: Bundle?) {
        ActivitiesForFragments[this.javaClass.simpleName] = this
        super.onCreate(savedInstanceState)
        window.clearFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS)
        window.addFlags(WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS)
        window.addFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_NAVIGATION)
        window.statusBarColor = Color.TRANSPARENT
        setContentView(R.layout.activity_event)
        setSupportActionBar(toolbar)

        toolbar_layout.setCollapsedTitleTextAppearance(R.style.CollapsedAppBar)
        toolbar_layout.setExpandedTitleTextAppearance(R.style.ExpandedAppBar)

        val scheduleManager = ScheduleManagerGetter[this]
        val favorite = intent.getSerializableExtra("favorite") as AttendeeConFavorite
        val offerStar = intent.getBooleanExtra("offerStar", false)
        fromNotification = intent.getBooleanExtra("fromNotification", false)
        val event = favorite.findInConvention(scheduleManager.convention)
        toolbar_layout.title = favorite.getString(this)

        app_bar_image.setImageDrawable(
                Drawable.createFromStream(
                        assets.open( event?.assetImage?.get(applicationContext.runtimeLanguage) ?: KnownAssets.background),
                        null
                )
        )
        val language = runtimeLanguage
        val hourFormatter = SimpleDateFormat("HH:mm", language.locale)
        val dowFormatter = SimpleDateFormat("EEEE (d)", language.locale)

        val timerClickListener = View.OnClickListener{
            Intent(this, CountdownActivity::class.java).let {
                it.putExtra("label", favorite.getString(this))
                it.putExtra("counter", favorite.timeRange.start.timeInMillis)
                it.putExtra("finishesAt", favorite.timeRange.finish.timeInMillis)
                startActivity(it)
            }
        }

        keypairs.removeAllViews()
        inflateKeyPair(
                getString(R.string.schedule_event_key_activity),
                favorite.getString(this),
                keypairs
        )
        if(event?.subtitles?.get(language)?.isNotEmpty() == true)
            inflateKeyPair(
                    getString(R.string.schedule_event_key_detail),
                    event.subtitles[language]!!,
                    keypairs
            )
        val whenButton = inflateKeyPair(
                getString(R.string.schedule_event_key_when),
                getString(R.string.schedule_event_key_when_formatted).format(
                        dowFormatter.format(favorite.timeRange.start.timeInMillis),
                        hourFormatter.format(favorite.timeRange.start.timeInMillis),
                        hourFormatter.format(favorite.timeRange.finish.timeInMillis)
                ).capitalize(),
                keypairs
        ).apply {
            touchableIndicator.visibility = View.VISIBLE
            setOnClickListener(timerClickListener)
        }
        if(event!=null) {
            if(event.places.isNotEmpty())
                inflateKeyPair(
                        if(event.places.size==1)
                            getString(R.string.schedule_event_key_place)
                        else
                            getString(R.string.schedule_event_key_places),
                        TextualJoiner(language)[event.places.map { it.names[language]!! }],
                        keypairs
                )
            if(event.language!=null)
                inflateKeyPair(
                        getString(R.string.schedule_event_key_language),
                        getString(event.language.language),
                        keypairs
                )
            event.descriptions[language]?.let {
                if(it.isNotEmpty())
                inflateKeyPair(
                        getString(R.string.schedule_event_key_description),
                        it,
                        keypairs
                )
            if(event.tags.isNotEmpty())
                inflateKeyPair(
                        getString(R.string.schedule_event_key_category),
                        TextualJoiner(language)[event.tags.map { it.names[language]!! }],
                        keypairs
                )
            if(event.conbookPages.isNotEmpty())
                inflateKeyPair(
                        if(event.conbookPages.size==1)
                            getString(R.string.schedule_event_key_on_conbooks_page)
                        else
                            getString(R.string.schedule_event_key_on_conbooks_pages),
                        TextualJoiner(language)[event.conbookPages.map { it.toString() }],
                        keypairs
                )
            if(event.conbookId.isNotEmpty())
                inflateKeyPair(
                        getString(R.string.schedule_event_key_identified_on_conbook_as),
                        event.conbookId,
                        keypairs
                )
            if(event.attendableBy.isNotEmpty())
                inflateKeyPair(
                        if(event.attendableBy.size==1)
                            getString(R.string.schedule_event_key_elegible_registration)
                        else
                            getString(R.string.schedule_event_key_elegible_registrations),
                        TextualJoiner(language)[event.attendableBy.map { it.names[language]!! }],
                        keypairs
                )
            }
            @SuppressLint("RestrictedApi")
            if(event.hiddenFromTimeTable or (scheduleManager.attendeeFavorites.registrationTier.level !in event.attendableBy.map { it.level })) {
                fab.visibility = View.GONE
                fabCalendar.visibility = View.GONE
            }
        }
        @SuppressLint("RestrictedApi")
        if(!offerStar){
            fab.visibility = View.GONE
            fabCalendar.visibility = View.GONE
        }


        fab.setOnClickListener { _ ->
            fab.setImageResource(R.drawable.ic_star_half_white_24dp)
            if (favorite in scheduleManager.attendeeFavorites)
                scheduleManager.attendeeFavorites.remove(favorite)
            else
                scheduleManager.attendeeFavorites.add(favorite)
        }
        fab.isLongClickable = true
        fab.setOnLongClickListener {
            Snackbar.make(it.rootView, R.string.add_or_remove_favorite, Snackbar.LENGTH_LONG).apply {
                setActionTextColor(ContextCompat.getColor(this@EventActivity, R.color.colorBase20))
                view.setBackgroundColor(ContextCompat.getColor(this@EventActivity, R.color.colorBase03))
                view.let {
                    it.setPadding(
                            it.paddingLeft,
                            it.paddingTop,
                            it.paddingRight,
                            it.paddingBottom + (48 * Resources.getSystem().displayMetrics.density).toInt()
                    )
                    show()
                }
            }
            true
        }
        fabCalendar.setOnClickListener { _ ->
            val intent = Intent(Intent.ACTION_EDIT)
            intent.type = "vnd.android.cursor.item/event"
            intent.putExtra(CalendarContract.Events.TITLE, favorite.getString(this))
            if(event!=null) {
                intent.putExtra(CalendarContract.Events.EVENT_LOCATION, TextualJoiner(runtimeLanguage)[event.places.map { it.names[runtimeLanguage]?:"" }])
                intent.putExtra(CalendarContract.Events.DESCRIPTION, event.descriptions[runtimeLanguage])
            }
            intent.putExtra(CalendarContract.EXTRA_EVENT_BEGIN_TIME,
                    favorite.timeRange.start.timeInMillis)
            intent.putExtra(CalendarContract.EXTRA_EVENT_END_TIME,
                    favorite.timeRange.finish.timeInMillis)
            startActivity(intent)
        }
        fabCalendar.isLongClickable = true
        fabCalendar.setOnLongClickListener {
            Snackbar.make(it.rootView, R.string.adds_to_your_agenda_app, Snackbar.LENGTH_LONG).apply {
                setActionTextColor(ContextCompat.getColor(this@EventActivity, R.color.colorBase20))
                view.setBackgroundColor(ContextCompat.getColor(this@EventActivity, R.color.colorBase03))
                view.let {
                    it.setPadding(
                            it.paddingLeft,
                            it.paddingTop,
                            it.paddingRight,
                            it.paddingBottom + (48 * Resources.getSystem().displayMetrics.density).toInt()
                    )
                    show()
                }
            }
            true
        }
        whenButton.isLongClickable = true
        whenButton.setOnLongClickListener {
            Snackbar.make(it.rootView, R.string.opens_timer, Snackbar.LENGTH_LONG).apply {
                setActionTextColor(ContextCompat.getColor(this@EventActivity, R.color.colorBase20))
                view.setBackgroundColor(ContextCompat.getColor(this@EventActivity, R.color.colorBase03))
                view.let {
                    it.setPadding(
                            it.paddingLeft,
                            it.paddingTop,
                            it.paddingRight,
                            it.paddingBottom + (48 * Resources.getSystem().displayMetrics.density).toInt()
                    )
                    show()
                }
            }
            true
        }
        scheduleManager.addObserver (Observer { _, _ ->
            if (favorite in scheduleManager.attendeeFavorites)
                fab.setImageResource(R.drawable.ic_star_white_24dp)
            else
                fab.setImageResource(R.drawable.ic_star_border_white_24dp)
        }.apply { this.update(null, null) })
    }

    private fun inflateKeyPair(key: String, value: String, into: ViewGroup? = null) =
            layoutInflater.inflate(R.layout.activity_event_content_keypair).apply {
                textKey.text = key
                textValue.text = value
                into?.addView(this)
                touchableIndicator.visibility = View.GONE
            }

    override fun onBackPressed() {
        if (!fromNotification)
            super.onBackPressed()
        else {
            val intent = Intent(this, SplashActivity::class.java)
            intent.flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_TASK_ON_HOME
            intent.putExtra("fastStart", true)
            this.startActivity(intent)
            this.finish()
        }
    }
}