avh-plan-android/app/src/main/java/com/denizd/substitutionplan/DataFetcher.kt

package com.denizd.substitutionplan

import android.app.*
import android.content.Context
import android.content.Intent
import android.graphics.Color
import android.media.RingtoneManager
import android.os.AsyncTask
import android.os.Build
import android.os.Handler
import android.os.Looper
import android.preference.PreferenceManager
import android.view.View
import android.view.animation.Animation
import android.view.animation.AnimationUtils
import android.widget.ProgressBar
import android.widget.RemoteViews
import androidx.core.app.NotificationCompat
import androidx.swiperefreshlayout.widget.SwipeRefreshLayout
import com.google.android.material.snackbar.Snackbar
import org.jsoup.Jsoup
import org.jsoup.select.Elements
import java.lang.IndexOutOfBoundsException
import java.net.URL
import java.text.SimpleDateFormat
import java.util.*
import kotlin.collections.ArrayList

class DataFetcher(isplan: Boolean, ismenu: Boolean, isjobservice: Boolean, context: Context, application: Application, parentview: View?) : AsyncTask<Void, Void, Void>() {

    private var jobservice = isjobservice
    private var plan = isplan
    private var menu = ismenu

    /*  booleans to improve speed when fetching data
        "plan" = true is required to fetch the substitution data
        "menu" = true is required to fetch the food menu
        "jobservice" = true is required to send a notification
        "jobservice" = true has no effect unless "plan" is also true
     */

    private var mContext = context
    private var mApplication = application
    private var mView = parentview
    private var priority = 200
    private var notifText = ""
    private var informational = ""
    private val prefs = PreferenceManager.getDefaultSharedPreferences(mContext)
    private val edit = prefs.edit()
    private lateinit var pullToRefresh: SwipeRefreshLayout
    private lateinit var progressBar: ProgressBar
    private val oldDateFormat = "EEE, dd MMM yyyy HH:mm:ss zzz"
    private val newDateFormat = "yyyy-MM-dd, HH:mm:ss"
    private var sdf = SimpleDateFormat(oldDateFormat)
    private lateinit var d: Date
    private val fadeOut = AnimationUtils.loadAnimation(mContext, R.anim.fade_out)
    private val handler = Handler(Looper.getMainLooper())

    override fun doInBackground(vararg params: Void?): Void? {
        try {
            mView?.let { v: View ->
                pullToRefresh = v.findViewById(R.id.pullToRefresh)
                progressBar = v.findViewById(R.id.progressBar)
                progressBar.progress = 0
            }
            if (menu) {
                val foodViewModel = FoodViewModel(mApplication)
                val docFood = Jsoup.connect("https://djd4rkn355.github.io/food.html").get()
                val foodElements = docFood.select("th")

                mView?.let {
                    progressBar.max = foodElements.size
                }

                var foodInt = 0
                var priority = 0
                foodViewModel.deleteAll()
                while (foodInt in 0 until foodElements.size) {
                    try { // what a mess this is!
                        if (foodElements[foodInt].text().contains("Montag") ||
                                foodElements[foodInt].text().contains("Dienstag") ||
                                foodElements[foodInt].text().contains("Mittwoch") ||
                                foodElements[foodInt].text().contains("Donnerstag") ||
                                foodElements[foodInt].text().contains("Freitag")) {

                            if (foodElements[foodInt + 3].text().contains("Montag") ||
                                    foodElements[foodInt + 3].text().contains("Dienstag") ||
                                    foodElements[foodInt + 3].text().contains("Mittwoch") ||
                                    foodElements[foodInt + 3].text().contains("Donnerstag") ||
                                    foodElements[foodInt + 3].text().contains("Freitag") ||
                                    foodElements[foodInt + 3].text().contains("von")) {
                                foodViewModel.insert(Food(foodElements[foodInt].text() + "\n"
                                        + foodElements[foodInt + 1].text() + "\n"
                                        + foodElements[foodInt + 2].text(), priority))
                                foodInt += 2
                            } else if (foodElements[foodInt + 2].text().contains("Montag") ||
                                    foodElements[foodInt + 2].text().contains("Dienstag") ||
                                    foodElements[foodInt + 2].text().contains("Mittwoch") ||
                                    foodElements[foodInt + 2].text().contains("Donnerstag") ||
                                    foodElements[foodInt + 2].text().contains("Freitag") ||
                                    foodElements[foodInt + 2].text().contains("von")) {
                                foodViewModel.insert(Food(foodElements[foodInt].text() + "\n"
                                        + foodElements[foodInt + 1].text(), priority))
                                foodInt += 1
                            }

                        } else {
                            foodViewModel.insert(Food(foodElements[foodInt].text(), priority))
                        }
                    } catch (e: IndexOutOfBoundsException) {
                        try {
                            foodViewModel.insert(Food(foodElements[foodInt].text() + "\n"
                                    + foodElements[foodInt + 1].text() + "\n"
                                    + foodElements[foodInt + 2].text(), priority))
                            break
                        } catch (e1: IndexOutOfBoundsException) {
                            foodViewModel.insert(Food(foodElements[foodInt].text() + "\n"
                                    + foodElements[foodInt + 1].text(), priority))
                            break
                        }
                    }
                    foodInt++
                    priority++
                    mView?.let {
                        progressBar.progress = foodInt
                    }
                }

                mView?.let {
                    progressBar.progress = 100
                    handler.postDelayed({ progressBar.startAnimation(fadeOut) }, 200)
                    fadeOut.setAnimationListener(object: Animation.AnimationListener {
                        override fun onAnimationStart(arg0: Animation) {}
                        override fun onAnimationRepeat(arg0: Animation) {}
                        override fun onAnimationEnd(arg0: Animation) {
                            progressBar.progress = 0
                        }
                    })
                }
            }

            if (plan) {
                val substViewModel = SubstViewModel(mApplication)
                val doc = Jsoup.connect("https://djd4rkn355.github.io/subst_test").get()
                val connection = URL("https://djd4rkn355.github.io/subst").openConnection()
                edit.putString("time", connection.getHeaderField("Last-Modified")).apply()
                d = sdf.parse(connection.getHeaderField("Last-Modified"))
                val rows = doc.select("tr")
                val paragraphs = doc.select("p")

                val groupS = ArrayList<String>()
                val dateS = ArrayList<String>()
                val timeS = ArrayList<String>()
                val courseS = ArrayList<String>()
                val roomS = ArrayList<String>()
                val additionalS = ArrayList<String>()

                mView?.let {
                    progressBar.max = rows.size
                }

                for (i in 0 until paragraphs.size) {
                    if (i == 0) {
                        informational = paragraphs[i].text()
                    } else {
                        informational += "\n\n" + paragraphs[i].text()
                    }
                }
                edit.putString("informational", informational).apply()

                substViewModel.deleteAllSubst()

                for (i in 0 until rows.size) {
                    val row = rows[i]
                    val cols = row.select("th") as Elements

                    groupS.add(cols[0].text())
                    dateS.add(cols[1].text())
                    timeS.add(cols[2].text())
                    courseS.add(cols[3].text())
                    roomS.add(cols[4].text())
                    additionalS.add(cols[5].text())
                    if (!jobservice) {
                        mView?.let {
                            progressBar.incrementProgressBy(1)
                        }
                    }

                    val drawable = MiscData.getIcon(courseS[i])
                    val subst = Subst(drawable, groupS[i], dateS[i], timeS[i], courseS[i],
                            roomS[i], additionalS[i], priority)
                    priority--
                    substViewModel.insertSubst(subst)

                    if (jobservice) {
                        if ((prefs.getString("courses", "") ?: "").isEmpty() && (prefs.getString("classes", "") ?: "").isNotEmpty()) {
                            if (groupS[i].isNotEmpty() && groupS[i] != "") {
                                if ((prefs.getString("classes", "") ?: "").contains(groupS[i]) || groupS[i].contains((prefs.getString("classes", "") ?: "").toString())) {
                                    if (notifText.isNotEmpty()) {
                                        notifText += ", "
                                    }
                                    notifText += courseS[i] + ": " + additionalS[i]
                                }
                            }
                        } else if ((prefs.getString("classes", "") ?: "").isNotEmpty() && (prefs.getString("courses", "") ?: "").isNotEmpty()) {
                            if (groupS[i] != "" && courseS[i] != "") {
                                if ((prefs.getString("courses", "") ?: "").contains(courseS[i])) {
                                    if ((prefs.getString("classes", "") ?: "").contains(groupS[i]) || groupS[i].contains((prefs.getString("classes", "") ?: "").toString())) {
                                        if (notifText.isNotEmpty()) {
                                            notifText += ", "
                                        }
                                        notifText += courseS[i] + ": " + additionalS[i]
                                    }
                                }
                            }
                        }
                    }
                }
                if (jobservice) {
                    val openApp = Intent(mContext, Main::class.java)
                    openApp.flags = Intent.FLAG_ACTIVITY_NEW_TASK
                    openApp.flags += Intent.FLAG_ACTIVITY_CLEAR_TASK
                    val openAppPending = PendingIntent.getActivity(mContext, 0, openApp, 0)

                    val notificationLayout = RemoteViews(mContext.packageName, R.layout.notification)
                    notificationLayout.setTextViewText(R.id.notification_title, mContext.getString(R.string.subst))
                    notificationLayout.setTextViewText(R.id.notification_textview, notifText)

                    if (notifText.isNotEmpty()) {
                        val manager = mContext.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
                        val channelId = "general"
                        val channelName = mContext.getString(R.string.general)

                        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
                            val channel = NotificationChannel(channelId, channelName, NotificationManager.IMPORTANCE_DEFAULT)
                            channel.enableLights(true)
                            channel.lightColor = Color.BLUE
                            manager.createNotificationChannel(channel)
                        }

                        val notification = NotificationCompat.Builder(mContext, channelId)
                                .setStyle(NotificationCompat.DecoratedCustomViewStyle())
                                .setCustomContentView(notificationLayout)
                                .setSmallIcon(R.drawable.ic_avh)
                                .setContentIntent(openAppPending)
                                .setAutoCancel(true)
                                .setSound(RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION))
                                .build()
                        manager.notify(1, notification)
                    }
                }
            }
            if (plan || menu) {
                mView?.let { v: View ->
                    handler.postDelayed({ progressBar.startAnimation(fadeOut) }, 200)
                    fadeOut.setAnimationListener(object: Animation.AnimationListener {
                        override fun onAnimationStart(arg0: Animation) {}
                        override fun onAnimationRepeat(arg0: Animation) {}
                        override fun onAnimationEnd(arg0: Animation) {
                            progressBar.progress = 0
                        }
                    })
                    pullToRefresh.isRefreshing = false
                    if (plan) {
                        val snackBarView = v.findViewById<View>(R.id.coordination)
                        sdf.applyPattern(newDateFormat)
                        val sb = StringBuilder()
                        val lastUpdated = sb.append(mContext.getText(R.string.lastupdatedK)).append(sdf.format(d)).toString()
                        Snackbar.make(snackBarView, lastUpdated, Snackbar.LENGTH_LONG).show()
                    }
                }
            }

        } catch (e: Exception) {
            mView?.let { v: View ->
                try {
                    pullToRefresh.isRefreshing = false
                } catch (ignored: Exception) {}
                val snackBarView = v.findViewById<View>(R.id.coordination)
                Snackbar.make(snackBarView, mContext.getText(R.string.nointernet), Snackbar.LENGTH_LONG).show()
            }
        }
        return null
    }
}