packages/EasterEgg/src/com/android/egg/neko/NekoControlsService.kt

/*
 * Copyright (C) 2020 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.egg.neko

import android.app.PendingIntent
import android.content.Intent
import android.content.res.ColorStateList
import android.graphics.drawable.Icon
import android.service.controls.Control
import android.service.controls.ControlsProviderService
import android.service.controls.DeviceTypes
import android.service.controls.actions.ControlAction
import android.service.controls.actions.FloatAction
import android.service.controls.templates.ControlButton
import android.service.controls.templates.RangeTemplate
import android.service.controls.templates.StatelessTemplate
import android.service.controls.templates.ToggleTemplate
import android.text.SpannableStringBuilder
import android.text.style.ForegroundColorSpan
import android.util.Log
import androidx.annotation.RequiresApi
import com.android.internal.logging.MetricsLogger
import java.util.Random
import java.util.concurrent.Flow
import java.util.function.Consumer

import com.android.egg.R

const val CONTROL_ID_WATER = "water"
const val CONTROL_ID_FOOD = "food"
const val CONTROL_ID_TOY = "toy"

const val FOOD_SPAWN_CAT_DELAY_MINS = 5L

const val COLOR_FOOD_FG = 0xFFFF8000.toInt()
const val COLOR_FOOD_BG = COLOR_FOOD_FG and 0x40FFFFFF.toInt()
const val COLOR_WATER_FG = 0xFF0080FF.toInt()
const val COLOR_WATER_BG = COLOR_WATER_FG and 0x40FFFFFF.toInt()
const val COLOR_TOY_FG = 0xFFFF4080.toInt()
const val COLOR_TOY_BG = COLOR_TOY_FG and 0x40FFFFFF.toInt()

val P_TOY_ICONS = intArrayOf(
        1, R.drawable.ic_toy_mouse,
        1, R.drawable.ic_toy_fish,
        1, R.drawable.ic_toy_ball,
        1, R.drawable.ic_toy_laser
)

@RequiresApi(30)
fun Control_toString(control: Control): String {
    val hc = String.format("0x%08x", control.hashCode())
    return ("Control($hc id=${control.controlId}, type=${control.deviceType}, " +
        "title=${control.title}, template=${control.controlTemplate})")
}

@RequiresApi(30)
public class NekoControlsService : ControlsProviderService(), PrefState.PrefsListener {
    private val TAG = "NekoControls"

    private val controls = HashMap<String, Control>()
    private val publishers = ArrayList<UglyPublisher>()
    private val rng = Random()

    private var lastToyIcon: Icon? = null

    private lateinit var prefs: PrefState

    override fun onCreate() {
        super.onCreate()

        prefs = PrefState(this)
        prefs.setListener(this)

        createDefaultControls()
    }

    override fun onPrefsChanged() {
        createDefaultControls()
    }

    private fun createDefaultControls() {
        val foodState: Int = prefs.foodState
        if (foodState != 0) {
            NekoService.registerJobIfNeeded(this, FOOD_SPAWN_CAT_DELAY_MINS)
        }

        val water = prefs.waterState

        controls[CONTROL_ID_WATER] = makeWaterBowlControl(water)
        controls[CONTROL_ID_FOOD] = makeFoodBowlControl(foodState != 0)
        controls[CONTROL_ID_TOY] = makeToyControl(currentToyIcon(), false)
    }

    private fun currentToyIcon(): Icon {
        val icon = lastToyIcon ?: randomToyIcon()
        lastToyIcon = icon
        return icon
    }

    private fun randomToyIcon(): Icon {
        return Icon.createWithResource(resources, Cat.chooseP(rng, P_TOY_ICONS, 4))
    }

    private fun colorize(s: CharSequence, color: Int): CharSequence {
        val ssb = SpannableStringBuilder(s)
        ssb.setSpan(ForegroundColorSpan(color), 0, s.length, 0)
        return ssb
    }

    private fun makeToyControl(icon: Icon?, thrown: Boolean): Control {
        return Control.StatefulBuilder(CONTROL_ID_TOY, getPendingIntent())
                .setDeviceType(DeviceTypes.TYPE_UNKNOWN)
                .setCustomIcon(icon)
                        //  ?.setTint(COLOR_TOY_FG)) // TODO(b/159559045): uncomment when fixed
                .setCustomColor(ColorStateList.valueOf(COLOR_TOY_BG))
                .setTitle(colorize(getString(R.string.control_toy_title), COLOR_TOY_FG))
                .setStatusText(colorize(
                        if (thrown) getString(R.string.control_toy_status) else "",
                        COLOR_TOY_FG))
                .setControlTemplate(StatelessTemplate("toy"))
                .setStatus(Control.STATUS_OK)
                .setSubtitle(if (thrown) "" else getString(R.string.control_toy_subtitle))
                .setAppIntent(getAppIntent())
                .build()
    }

    private fun makeWaterBowlControl(fillLevel: Float): Control {
        return Control.StatefulBuilder(CONTROL_ID_WATER, getPendingIntent())
                .setDeviceType(DeviceTypes.TYPE_KETTLE)
                .setTitle(colorize(getString(R.string.control_water_title), COLOR_WATER_FG))
                .setCustomColor(ColorStateList.valueOf(COLOR_WATER_BG))
                .setCustomIcon(Icon.createWithResource(resources,
                        if (fillLevel >= 100f) R.drawable.ic_water_filled else R.drawable.ic_water))
                        //.setTint(COLOR_WATER_FG)) // TODO(b/159559045): uncomment when fixed
                .setControlTemplate(RangeTemplate("waterlevel", 0f, 200f, fillLevel, 10f,
                        "%.0f mL"))
                .setStatus(Control.STATUS_OK)
                .setSubtitle(if (fillLevel == 0f) getString(R.string.control_water_subtitle) else "")
                .build()
    }

    private fun makeFoodBowlControl(filled: Boolean): Control {
        return Control.StatefulBuilder(CONTROL_ID_FOOD, getPendingIntent())
                .setDeviceType(DeviceTypes.TYPE_UNKNOWN)
                .setCustomColor(ColorStateList.valueOf(COLOR_FOOD_BG))
                .setTitle(colorize(getString(R.string.control_food_title), COLOR_FOOD_FG))
                .setCustomIcon(Icon.createWithResource(resources,
                        if (filled) R.drawable.ic_foodbowl_filled else R.drawable.ic_bowl))
                        // .setTint(COLOR_FOOD_FG)) // TODO(b/159559045): uncomment when fixed
                .setStatusText(
                        if (filled) colorize(
                                getString(R.string.control_food_status_full), 0xCCFFFFFF.toInt())
                        else colorize(
                                getString(R.string.control_food_status_empty), 0x80FFFFFF.toInt()))
                .setControlTemplate(ToggleTemplate("foodbowl", ControlButton(filled, "Refill")))
                .setStatus(Control.STATUS_OK)
                .setSubtitle(if (filled) "" else getString(R.string.control_food_subtitle))
                .build()
    }

    private fun getPendingIntent(): PendingIntent {
        val intent = Intent(Intent.ACTION_MAIN)
                .setClass(this, NekoLand::class.java)
                .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
        return PendingIntent.getActivity(this, 0, intent,
            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE)
    }

    private fun getAppIntent(): PendingIntent {
        return getPendingIntent()
    }


    override fun performControlAction(
        controlId: String,
        action: ControlAction,
        consumer: Consumer<Int>
    ) {
        when (controlId) {
            CONTROL_ID_FOOD -> {
                // refill bowl
                controls[CONTROL_ID_FOOD] = makeFoodBowlControl(true)
                Log.v(TAG, "Bowl refilled. (Registering job.)")
                NekoService.registerJob(this, FOOD_SPAWN_CAT_DELAY_MINS)
                MetricsLogger.histogram(this, "egg_neko_offered_food", 11)
                prefs.foodState = 11
            }
            CONTROL_ID_TOY -> {
                Log.v(TAG, "Toy tossed.")
                controls[CONTROL_ID_TOY] =
                    makeToyControl(currentToyIcon(), true)
                // TODO: re-enable toy
                Thread() {
                    Thread.sleep((1 + Random().nextInt(4)) * 1000L)
                    NekoService.getExistingCat(prefs)?.let {
                        NekoService.notifyCat(this, it)
                    }
                    controls[CONTROL_ID_TOY] = makeToyControl(randomToyIcon(), false)
                    pushControlChanges()
                }.start()
            }
            CONTROL_ID_WATER -> {
                if (action is FloatAction) {
                    controls[CONTROL_ID_WATER] = makeWaterBowlControl(action.newValue)
                    Log.v(TAG, "Water level set to " + action.newValue)
                    prefs.waterState = action.newValue
                }
            }
            else -> {
                return
            }
        }
        consumer.accept(ControlAction.RESPONSE_OK)
        pushControlChanges()
    }

    private fun pushControlChanges() {
        Thread() {
            publishers.forEach { it.refresh() }
        }.start()
    }

    private fun makeStateless(c: Control?): Control? {
        if (c == null) return null
        return Control.StatelessBuilder(c.controlId, c.appIntent)
                .setTitle(c.title)
                .setSubtitle(c.subtitle)
                .setStructure(c.structure)
                .setDeviceType(c.deviceType)
                .setCustomIcon(c.customIcon)
                .setCustomColor(c.customColor)
                .build()
    }

    override fun createPublisherFor(list: MutableList<String>): Flow.Publisher<Control> {
        createDefaultControls()

        val publisher = UglyPublisher(list, true)
        publishers.add(publisher)
        return publisher
    }

    override fun createPublisherForAllAvailable(): Flow.Publisher<Control> {
        createDefaultControls()

        val publisher = UglyPublisher(controls.keys, false)
        publishers.add(publisher)
        return publisher
    }

    private inner class UglyPublisher(
        val controlKeys: Iterable<String>,
        val indefinite: Boolean
    ) : Flow.Publisher<Control> {
        val subscriptions = ArrayList<UglySubscription>()

        private inner class UglySubscription(
            val initialControls: Iterator<Control>,
            var subscriber: Flow.Subscriber<in Control>?
        ) : Flow.Subscription {
            override fun cancel() {
                Log.v(TAG, "cancel subscription: $this for subscriber: $subscriber " +
                        "to publisher: $this@UglyPublisher")
                subscriber = null
                unsubscribe(this)
            }

            override fun request(p0: Long) {
                (0 until p0).forEach { _ ->
                    if (initialControls.hasNext()) {
                        send(initialControls.next())
                    } else {
                        if (!indefinite) subscriber?.onComplete()
                    }
                }
            }

            fun send(c: Control) {
                Log.v(TAG, "sending update: " + Control_toString(c) + " => " + subscriber)
                subscriber?.onNext(c)
            }
        }

        override fun subscribe(subscriber: Flow.Subscriber<in Control>) {
            Log.v(TAG, "subscribe to publisher: $this by subscriber: $subscriber")
            val sub = UglySubscription(controlKeys.mapNotNull { controls[it] }.iterator(),
            subscriber)
            subscriptions.add(sub)
            subscriber.onSubscribe(sub)
        }

        fun unsubscribe(sub: UglySubscription) {
            Log.v(TAG, "no more subscriptions, removing subscriber: $sub")
            subscriptions.remove(sub)
            if (subscriptions.size == 0) {
                Log.v(TAG, "no more subscribers, removing publisher: $this")
                publishers.remove(this)
            }
        }

        fun refresh() {
            controlKeys.mapNotNull { controls[it] }.forEach { control ->
                subscriptions.forEach { sub ->
                    sub.send(control)
                }
            }
        }
    }
}