/*
 * Copyright (C) 2021 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.calendar

import android.animation.Animator
import android.animation.AnimatorListenerAdapter
import android.animation.ObjectAnimator
import android.animation.ValueAnimator
import android.app.Service
import android.content.Context
import android.content.res.Resources
import android.content.res.TypedArray
import android.graphics.Canvas
import android.graphics.Paint
import android.graphics.Paint.Align
import android.graphics.Paint.Style
import android.graphics.Rect
import android.graphics.Typeface
import android.graphics.drawable.Drawable
import android.os.Handler
import android.provider.CalendarContract.Attendees
import android.provider.CalendarContract.Calendars
import android.text.Layout.Alignment
import android.text.SpannableStringBuilder
import android.text.StaticLayout
import android.text.TextPaint
import android.text.format.DateFormat
import android.text.format.DateUtils
import android.text.format.Time
import android.text.style.StyleSpan
import android.util.Log
import android.view.ContextMenu
import android.view.ContextMenu.ContextMenuInfo
import android.view.GestureDetector
import android.view.KeyEvent
import android.view.LayoutInflater
import android.view.MenuItem
import android.view.MotionEvent
import android.view.ScaleGestureDetector
import android.view.View
import android.view.ViewConfiguration
import android.view.ViewGroup
import android.view.ViewGroup.LayoutParams
import android.view.WindowManager
import android.view.accessibility.AccessibilityEvent
import android.view.accessibility.AccessibilityManager
import android.view.animation.AccelerateDecelerateInterpolator
import android.view.animation.Animation
import android.view.animation.Interpolator
import android.view.animation.TranslateAnimation
import android.widget.EdgeEffect
import android.widget.OverScroller
import android.widget.PopupWindow
import android.widget.ViewSwitcher
import com.android.calendar.CalendarController.EventType
import com.android.calendar.CalendarController.ViewType
import java.util.ArrayList
import java.util.Arrays
import java.util.Calendar
import java.util.Formatter
import java.util.Locale
import java.util.regex.Matcher
import java.util.regex.Pattern

/**
 * View for multi-day view. So far only 1 and 7 day have been tested.
 */
class DayView(
    context: Context?,
    controller: CalendarController?,
    viewSwitcher: ViewSwitcher?,
    eventLoader: EventLoader?,
    numDays: Int
) : View(context), View.OnCreateContextMenuListener, ScaleGestureDetector.OnScaleGestureListener,
    View.OnClickListener, View.OnLongClickListener {
    private var mOnFlingCalled = false
    private var mStartingScroll = false
    protected var mPaused = true
    private var mHandler: Handler? = null

    /**
     * ID of the last event which was displayed with the toast popup.
     *
     * This is used to prevent popping up multiple quick views for the same event, especially
     * during calendar syncs. This becomes valid when an event is selected, either by default
     * on starting calendar or by scrolling to an event. It becomes invalid when the user
     * explicitly scrolls to an empty time slot, changes views, or deletes the event.
     */
    private var mLastPopupEventID: Long
    protected var mContext: Context? = null
    private val mContinueScroll: ContinueScroll = ContinueScroll()

    // Make this visible within the package for more informative debugging
    var mBaseDate: Time? = null
    private var mCurrentTime: Time? = null
    private val mUpdateCurrentTime: UpdateCurrentTime = UpdateCurrentTime()
    private var mTodayJulianDay = 0
    private val mBold: Typeface = Typeface.DEFAULT_BOLD
    private var mFirstJulianDay = 0
    private var mLoadedFirstJulianDay = -1
    private var mLastJulianDay = 0
    private var mMonthLength = 0
    private var mFirstVisibleDate = 0
    private var mFirstVisibleDayOfWeek = 0
    private var mEarliestStartHour: IntArray? = null // indexed by the week day offset
    private var mHasAllDayEvent: BooleanArray? = null // indexed by the week day offset
    private var mEventCountTemplate: String? = null
    private var mClickedEvent: Event? = null // The event the user clicked on
    private var mSavedClickedEvent: Event? = null
    private var mClickedYLocation = 0
    private var mDownTouchTime: Long = 0
    private var mEventsAlpha = 255
    private var mEventsCrossFadeAnimation: ObjectAnimator? = null
    private val mTZUpdater: Runnable = object : Runnable {
        @Override
        override fun run() {
            val tz: String? = Utils.getTimeZone(mContext, this)
            mBaseDate!!.timezone = tz
            mBaseDate?.normalize(true)
            mCurrentTime?.switchTimezone(tz)
            invalidate()
        }
    }

    // Sets the "clicked" color from the clicked event
    private val mSetClick: Runnable = object : Runnable {
        @Override
        override fun run() {
            mClickedEvent = mSavedClickedEvent
            mSavedClickedEvent = null
            this@DayView.invalidate()
        }
    }

    // Clears the "clicked" color from the clicked event and launch the event
    private val mClearClick: Runnable = object : Runnable {
        @Override
        override fun run() {
            if (mClickedEvent != null) {
                mController.sendEventRelatedEvent(
                    this as Object?, EventType.VIEW_EVENT, mClickedEvent!!.id,
                    mClickedEvent!!.startMillis, mClickedEvent!!.endMillis,
                    this@DayView.getWidth() / 2, mClickedYLocation,
                    selectedTimeInMillis
                )
            }
            mClickedEvent = null
            this@DayView.invalidate()
        }
    }
    private val mTodayAnimatorListener: TodayAnimatorListener = TodayAnimatorListener()

    internal inner class TodayAnimatorListener : AnimatorListenerAdapter() {
        @Volatile
        private var mAnimator: Animator? = null

        @Volatile
        private var mFadingIn = false
        @Override
        override fun onAnimationEnd(animation: Animator) {
            synchronized(this) {
                if (mAnimator !== animation) {
                    animation.removeAllListeners()
                    animation.cancel()
                    return
                }
                if (mFadingIn) {
                    if (mTodayAnimator != null) {
                        mTodayAnimator?.removeAllListeners()
                        mTodayAnimator?.cancel()
                    }
                    mTodayAnimator = ObjectAnimator
                        .ofInt(this@DayView, "animateTodayAlpha", 255, 0)
                    mAnimator = mTodayAnimator
                    mFadingIn = false
                    mTodayAnimator?.addListener(this)
                    mTodayAnimator?.setDuration(600)
                    mTodayAnimator?.start()
                } else {
                    mAnimateToday = false
                    mAnimateTodayAlpha = 0
                    mAnimator?.removeAllListeners()
                    mAnimator = null
                    mTodayAnimator = null
                    invalidate()
                }
            }
        }

        fun setAnimator(animation: Animator?) {
            mAnimator = animation
        }

        fun setFadingIn(fadingIn: Boolean) {
            mFadingIn = fadingIn
        }
    }

    var mAnimatorListener: AnimatorListenerAdapter = object : AnimatorListenerAdapter() {
        @Override
        override fun onAnimationStart(animation: Animator) {
            mScrolling = true
        }

        @Override
        override fun onAnimationCancel(animation: Animator) {
            mScrolling = false
        }

        @Override
        override fun onAnimationEnd(animation: Animator) {
            mScrolling = false
            resetSelectedHour()
            invalidate()
        }
    }

    /**
     * This variable helps to avoid unnecessarily reloading events by keeping
     * track of the start millis parameter used for the most recent loading
     * of events.  If the next reload matches this, then the events are not
     * reloaded.  To force a reload, set this to zero (this is set to zero
     * in the method clearCachedEvents()).
     */
    private var mLastReloadMillis: Long = 0
    private var mEvents: ArrayList<Event> = ArrayList<Event>()
    private var mAllDayEvents: ArrayList<Event>? = ArrayList<Event>()
    private var mLayouts: Array<StaticLayout?>? = null
    private var mAllDayLayouts: Array<StaticLayout?>? = null
    private var mSelectionDay = 0 // Julian day
    private var mSelectionHour = 0
    var mSelectionAllday = false

    // Current selection info for accessibility
    private var mSelectionDayForAccessibility = 0 // Julian day
    private var mSelectionHourForAccessibility = 0
    private var mSelectedEventForAccessibility: Event? = null

    // Last selection info for accessibility
    private var mLastSelectionDayForAccessibility = 0
    private var mLastSelectionHourForAccessibility = 0
    private var mLastSelectedEventForAccessibility: Event? = null

    /** Width of a day or non-conflicting event  */
    private var mCellWidth = 0

    // Pre-allocate these objects and re-use them
    private val mRect: Rect = Rect()
    private val mDestRect: Rect = Rect()
    private val mSelectionRect: Rect = Rect()

    // This encloses the more allDay events icon
    private val mExpandAllDayRect: Rect = Rect()

    // TODO Clean up paint usage
    private val mPaint: Paint = Paint()
    private val mEventTextPaint: Paint = Paint()
    private val mSelectionPaint: Paint = Paint()
    private var mLines: FloatArray = emptyArray<Float>().toFloatArray()
    private var mFirstDayOfWeek = 0 // First day of the week
    private var mPopup: PopupWindow? = null
    private var mPopupView: View? = null
    private val mDismissPopup: DismissPopup = DismissPopup()
    private var mRemeasure = true
    private val mEventLoader: EventLoader
    protected val mEventGeometry: EventGeometry
    private var mAnimationDistance = 0f
    private var mViewStartX = 0
    private var mViewStartY = 0
    private var mMaxViewStartY = 0
    private var mViewHeight = 0
    private var mViewWidth = 0
    private var mGridAreaHeight = -1
    private var mScrollStartY = 0
    private var mPreviousDirection = 0

    /**
     * Vertical distance or span between the two touch points at the start of a
     * scaling gesture
     */
    private var mStartingSpanY = 0f

    /** Height of 1 hour in pixels at the start of a scaling gesture  */
    private var mCellHeightBeforeScaleGesture = 0

    /** The hour at the center two touch points  */
    private var mGestureCenterHour = 0f
    private var mRecalCenterHour = false

    /**
     * Flag to decide whether to handle the up event. Cases where up events
     * should be ignored are 1) right after a scale gesture and 2) finger was
     * down before app launch
     */
    private var mHandleActionUp = true
    private var mHoursTextHeight = 0

    /**
     * The height of the area used for allday events
     */
    private var mAlldayHeight = 0

    /**
     * The height of the allday event area used during animation
     */
    private var mAnimateDayHeight = 0

    /**
     * The height of an individual allday event during animation
     */
    private var mAnimateDayEventHeight = MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT.toInt()

    /**
     * Max of all day events in a given day in this view.
     */
    private var mMaxAlldayEvents = 0

    /**
     * A count of the number of allday events that were not drawn for each day
     */
    private var mSkippedAlldayEvents: IntArray? = null

    /**
     * The number of allDay events at which point we start hiding allDay events.
     */
    private var mMaxUnexpandedAlldayEventCount = 4
    protected var mNumDays = 7
    private var mNumHours = 10

    /** Width of the time line (list of hours) to the left.  */
    private var mHoursWidth = 0
    private var mDateStrWidth = 0

    /** Top of the scrollable region i.e. below date labels and all day events  */
    private var mFirstCell = 0

    /** First fully visible hour  */
    private var mFirstHour = -1

    /** Distance between the mFirstCell and the top of first fully visible hour.  */
    private var mFirstHourOffset = 0
    private var mHourStrs: Array<String>? = null
    private var mDayStrs: Array<String?>? = null
    private var mDayStrs2Letter: Array<String?>? = null
    private var mIs24HourFormat = false
    private val mSelectedEvents: ArrayList<Event> = ArrayList<Event>()
    private var mComputeSelectedEvents = false
    private var mUpdateToast = false
    private var mSelectedEvent: Event? = null
    private var mPrevSelectedEvent: Event? = null
    private val mPrevBox: Rect = Rect()
    protected val mResources: Resources
    protected val mCurrentTimeLine: Drawable
    protected val mCurrentTimeAnimateLine: Drawable
    protected val mTodayHeaderDrawable: Drawable
    protected val mExpandAlldayDrawable: Drawable
    protected val mCollapseAlldayDrawable: Drawable
    protected var mAcceptedOrTentativeEventBoxDrawable: Drawable
    private var mAmString: String? = null
    private var mPmString: String? = null
    var mScaleGestureDetector: ScaleGestureDetector
    private var mTouchMode = TOUCH_MODE_INITIAL_STATE
    private var mSelectionMode = SELECTION_HIDDEN
    private var mScrolling = false

    // Pixels scrolled
    private var mInitialScrollX = 0f
    private var mInitialScrollY = 0f
    private var mAnimateToday = false
    private var mAnimateTodayAlpha = 0

    // Animates the height of the allday region
    var mAlldayAnimator: ObjectAnimator? = null

    // Animates the height of events in the allday region
    var mAlldayEventAnimator: ObjectAnimator? = null

    // Animates the transparency of the more events text
    var mMoreAlldayEventsAnimator: ObjectAnimator? = null

    // Animates the current time marker when Today is pressed
    var mTodayAnimator: ObjectAnimator? = null

    // whether or not an event is stopping because it was cancelled
    private var mCancellingAnimations = false

    // tracks whether a touch originated in the allday area
    private var mTouchStartedInAlldayArea = false
    private val mController: CalendarController
    private val mViewSwitcher: ViewSwitcher
    private val mGestureDetector: GestureDetector
    private val mScroller: OverScroller
    private val mEdgeEffectTop: EdgeEffect
    private val mEdgeEffectBottom: EdgeEffect
    private var mCallEdgeEffectOnAbsorb = false
    private val OVERFLING_DISTANCE: Int
    private var mLastVelocity = 0f
    private val mHScrollInterpolator: ScrollInterpolator
    private var mAccessibilityMgr: AccessibilityManager? = null
    private var mIsAccessibilityEnabled = false
    private var mTouchExplorationEnabled = false
    private val mNewEventHintString: String
    @Override
    protected override fun onAttachedToWindow() {
        if (mHandler == null) {
            mHandler = getHandler()
            mHandler?.post(mUpdateCurrentTime)
        }
    }

    private fun init(context: Context) {
        setFocusable(true)

        // Allow focus in touch mode so that we can do keyboard shortcuts
        // even after we've entered touch mode.
        setFocusableInTouchMode(true)
        setClickable(true)
        setOnCreateContextMenuListener(this)
        mFirstDayOfWeek = Utils.getFirstDayOfWeek(context)
        mCurrentTime = Time(Utils.getTimeZone(context, mTZUpdater))
        val currentTime: Long = System.currentTimeMillis()
        mCurrentTime?.set(currentTime)
        mTodayJulianDay = Time.getJulianDay(currentTime, mCurrentTime!!.gmtoff)
        mWeek_saturdayColor = mResources.getColor(R.color.week_saturday)
        mWeek_sundayColor = mResources.getColor(R.color.week_sunday)
        mCalendarDateBannerTextColor = mResources.getColor(R.color.calendar_date_banner_text_color)
        mFutureBgColorRes = mResources.getColor(R.color.calendar_future_bg_color)
        mBgColor = mResources.getColor(R.color.calendar_hour_background)
        mCalendarAmPmLabel = mResources.getColor(R.color.calendar_ampm_label)
        mCalendarGridAreaSelected = mResources.getColor(R.color.calendar_grid_area_selected)
        mCalendarGridLineInnerHorizontalColor = mResources
            .getColor(R.color.calendar_grid_line_inner_horizontal_color)
        mCalendarGridLineInnerVerticalColor = mResources
            .getColor(R.color.calendar_grid_line_inner_vertical_color)
        mCalendarHourLabelColor = mResources.getColor(R.color.calendar_hour_label)
        mEventTextColor = mResources.getColor(R.color.calendar_event_text_color)
        mMoreEventsTextColor = mResources.getColor(R.color.month_event_other_color)
        mEventTextPaint.setTextSize(EVENT_TEXT_FONT_SIZE)
        mEventTextPaint.setTextAlign(Paint.Align.LEFT)
        mEventTextPaint.setAntiAlias(true)
        val gridLineColor: Int = mResources.getColor(R.color.calendar_grid_line_highlight_color)
        var p: Paint = mSelectionPaint
        p.setColor(gridLineColor)
        p.setStyle(Style.FILL)
        p.setAntiAlias(false)
        p = mPaint
        p.setAntiAlias(true)

        // Allocate space for 2 weeks worth of weekday names so that we can
        // easily start the week display at any week day.
        mDayStrs = arrayOfNulls(14)

        // Also create an array of 2-letter abbreviations.
        mDayStrs2Letter = arrayOfNulls(14)
        for (i in Calendar.SUNDAY..Calendar.SATURDAY) {
            val index: Int = i - Calendar.SUNDAY
            // e.g. Tue for Tuesday
            mDayStrs!![index] = DateUtils.getDayOfWeekString(i, DateUtils.LENGTH_MEDIUM)
                .toUpperCase()
            mDayStrs!![index + 7] = mDayStrs!![index]
            // e.g. Tu for Tuesday
            mDayStrs2Letter!![index] = DateUtils.getDayOfWeekString(i, DateUtils.LENGTH_SHORT)
                .toUpperCase()

            // If we don't have 2-letter day strings, fall back to 1-letter.
            if (mDayStrs2Letter!![index]!!.equals(mDayStrs!![index])) {
                mDayStrs2Letter!![index] = DateUtils.getDayOfWeekString(i,
                DateUtils.LENGTH_SHORTEST)
            }
            mDayStrs2Letter!![index + 7] = mDayStrs2Letter!![index]
        }

        // Figure out how much space we need for the 3-letter abbrev names
        // in the worst case.
        p.setTextSize(DATE_HEADER_FONT_SIZE)
        p.setTypeface(mBold)
        val dateStrs = arrayOf<String?>(" 28", " 30")
        mDateStrWidth = computeMaxStringWidth(0, dateStrs, p)
        p.setTextSize(DAY_HEADER_FONT_SIZE)
        mDateStrWidth += computeMaxStringWidth(0, mDayStrs as Array<String?>, p)
        p.setTextSize(HOURS_TEXT_SIZE)
        p.setTypeface(null)
        handleOnResume()
        mAmString = DateUtils.getAMPMString(Calendar.AM).toUpperCase()
        mPmString = DateUtils.getAMPMString(Calendar.PM).toUpperCase()
        val ampm = arrayOf(mAmString, mPmString)
        p.setTextSize(AMPM_TEXT_SIZE)
        mHoursWidth = Math.max(
            HOURS_MARGIN, computeMaxStringWidth(mHoursWidth, ampm, p) +
                HOURS_RIGHT_MARGIN
        )
        mHoursWidth = Math.max(MIN_HOURS_WIDTH, mHoursWidth)
        val inflater: LayoutInflater
        inflater = context.getSystemService(Context.LAYOUT_INFLATER_SERVICE) as LayoutInflater
        mPopupView = inflater.inflate(R.layout.bubble_event, null)
        mPopupView?.setLayoutParams(
            LayoutParams(
                ViewGroup.LayoutParams.MATCH_PARENT,
                ViewGroup.LayoutParams.WRAP_CONTENT
            )
        )
        mPopup = PopupWindow(context)
        mPopup?.setContentView(mPopupView)
        val dialogTheme: Resources.Theme = getResources().newTheme()
        dialogTheme.applyStyle(android.R.style.Theme_Dialog, true)
        val ta: TypedArray = dialogTheme.obtainStyledAttributes(
            intArrayOf(
                android.R.attr.windowBackground
            )
        )
        mPopup?.setBackgroundDrawable(ta.getDrawable(0))
        ta.recycle()

        // Enable touching the popup window
        mPopupView?.setOnClickListener(this)
        // Catch long clicks for creating a new event
        setOnLongClickListener(this)
        mBaseDate = Time(Utils.getTimeZone(context, mTZUpdater))
        val millis: Long = System.currentTimeMillis()
        mBaseDate?.set(millis)
        mEarliestStartHour = IntArray(mNumDays)
        mHasAllDayEvent = BooleanArray(mNumDays)

        // mLines is the array of points used with Canvas.drawLines() in
        // drawGridBackground() and drawAllDayEvents().  Its size depends
        // on the max number of lines that can ever be drawn by any single
        // drawLines() call in either of those methods.
        val maxGridLines = (24 + 1 + // max horizontal lines we might draw
            (mNumDays + 1)) // max vertical lines we might draw
        mLines = FloatArray(maxGridLines * 4)
    }

    /**
     * This is called when the popup window is pressed.
     */
    override fun onClick(v: View) {
        if (v === mPopupView) {
            // Pretend it was a trackball click because that will always
            // jump to the "View event" screen.
            switchViews(true /* trackball */)
        }
    }

    fun handleOnResume() {
        initAccessibilityVariables()
        if (Utils.getSharedPreference(mContext, OtherPreferences.KEY_OTHER_1, false)) {
            mFutureBgColor = 0
        } else {
            mFutureBgColor = mFutureBgColorRes
        }
        mIs24HourFormat = DateFormat.is24HourFormat(mContext)
        mHourStrs = if (mIs24HourFormat) CalendarData.s24Hours else CalendarData.s12HoursNoAmPm
        mFirstDayOfWeek = Utils.getFirstDayOfWeek(mContext)
        mLastSelectionDayForAccessibility = 0
        mLastSelectionHourForAccessibility = 0
        mLastSelectedEventForAccessibility = null
        mSelectionMode = SELECTION_HIDDEN
    }

    private fun initAccessibilityVariables() {
        mAccessibilityMgr = mContext
            ?.getSystemService(Service.ACCESSIBILITY_SERVICE) as AccessibilityManager
        mIsAccessibilityEnabled = mAccessibilityMgr != null && mAccessibilityMgr!!.isEnabled()
        mTouchExplorationEnabled = isTouchExplorationEnabled
    } /* ignore isDst */ // We ignore the "isDst" field because we want normalize() to figure
    // out the correct DST value and not adjust the selected time based
    // on the current setting of DST.
    /**
     * Returns the start of the selected time in milliseconds since the epoch.
     *
     * @return selected time in UTC milliseconds since the epoch.
     */
    val selectedTimeInMillis: Long
        get() {
            val time = Time(mBaseDate)
            time.setJulianDay(mSelectionDay)
            time.hour = mSelectionHour

            // We ignore the "isDst" field because we want normalize() to figure
            // out the correct DST value and not adjust the selected time based
            // on the current setting of DST.
            return time.normalize(true /* ignore isDst */)
        } /* ignore isDst */

    // We ignore the "isDst" field because we want normalize() to figure
    // out the correct DST value and not adjust the selected time based
    // on the current setting of DST.
    val selectedTime: Time
        get() {
            val time = Time(mBaseDate)
            time.setJulianDay(mSelectionDay)
            time.hour = mSelectionHour

            // We ignore the "isDst" field because we want normalize() to figure
            // out the correct DST value and not adjust the selected time based
            // on the current setting of DST.
            time.normalize(true /* ignore isDst */)
            return time
        } /* ignore isDst */

    // We ignore the "isDst" field because we want normalize() to figure
    // out the correct DST value and not adjust the selected time based
    // on the current setting of DST.
    val selectedTimeForAccessibility: Time
        get() {
            val time = Time(mBaseDate)
            time.setJulianDay(mSelectionDayForAccessibility)
            time.hour = mSelectionHourForAccessibility

            // We ignore the "isDst" field because we want normalize() to figure
            // out the correct DST value and not adjust the selected time based
            // on the current setting of DST.
            time.normalize(true /* ignore isDst */)
            return time
        }

    /**
     * Returns the start of the selected time in minutes since midnight,
     * local time.  The derived class must ensure that this is consistent
     * with the return value from getSelectedTimeInMillis().
     */
    val selectedMinutesSinceMidnight: Int
        get() = mSelectionHour * MINUTES_PER_HOUR
    var firstVisibleHour: Int
        get() = mFirstHour
        set(firstHour) {
            mFirstHour = firstHour
            mFirstHourOffset = 0
        }

    fun setSelected(time: Time?, ignoreTime: Boolean, animateToday: Boolean) {
        mBaseDate?.set(time)
        setSelectedHour(mBaseDate!!.hour)
        setSelectedEvent(null)
        mPrevSelectedEvent = null
        val millis: Long = mBaseDate!!.toMillis(false /* use isDst */)
        setSelectedDay(Time.getJulianDay(millis, mBaseDate!!.gmtoff))
        mSelectedEvents.clear()
        mComputeSelectedEvents = true
        var gotoY: Int = Integer.MIN_VALUE
        if (!ignoreTime && mGridAreaHeight != -1) {
            var lastHour = 0
            if (mBaseDate!!.hour < mFirstHour) {
                // Above visible region
                gotoY = mBaseDate!!.hour * (mCellHeight + HOUR_GAP)
            } else {
                lastHour = ((mGridAreaHeight - mFirstHourOffset) / (mCellHeight + HOUR_GAP) +
                    mFirstHour)
                if (mBaseDate!!.hour >= lastHour) {
                    // Below visible region

                    // target hour + 1 (to give it room to see the event) -
                    // grid height (to get the y of the top of the visible
                    // region)
                    gotoY = ((mBaseDate!!.hour + 1 + mBaseDate!!.minute / 60.0f) *
                        (mCellHeight + HOUR_GAP) - mGridAreaHeight).toInt()
                }
            }
            if (DEBUG) {
                Log.e(
                    TAG, "Go " + gotoY + " 1st " + mFirstHour + ":" + mFirstHourOffset + "CH " +
                        (mCellHeight + HOUR_GAP) + " lh " + lastHour + " gh " + mGridAreaHeight +
                        " ymax " + mMaxViewStartY
                )
            }
            if (gotoY > mMaxViewStartY) {
                gotoY = mMaxViewStartY
            } else if (gotoY < 0 && gotoY != Integer.MIN_VALUE) {
                gotoY = 0
            }
        }
        recalc()
        mRemeasure = true
        invalidate()
        var delayAnimateToday = false
        if (gotoY != Integer.MIN_VALUE) {
            val scrollAnim: ValueAnimator =
                ObjectAnimator.ofInt(this, "viewStartY", mViewStartY, gotoY)
            scrollAnim.setDuration(GOTO_SCROLL_DURATION.toLong())
            scrollAnim.setInterpolator(AccelerateDecelerateInterpolator())
            scrollAnim.addListener(mAnimatorListener)
            scrollAnim.start()
            delayAnimateToday = true
        }
        if (animateToday) {
            synchronized(mTodayAnimatorListener) {
                if (mTodayAnimator != null) {
                    mTodayAnimator?.removeAllListeners()
                    mTodayAnimator?.cancel()
                }
                mTodayAnimator = ObjectAnimator.ofInt(
                    this, "animateTodayAlpha",
                    mAnimateTodayAlpha, 255
                )
                mAnimateToday = true
                mTodayAnimatorListener.setFadingIn(true)
                mTodayAnimatorListener.setAnimator(mTodayAnimator)
                mTodayAnimator?.addListener(mTodayAnimatorListener)
                mTodayAnimator?.setDuration(150)
                if (delayAnimateToday) {
                    mTodayAnimator?.setStartDelay(GOTO_SCROLL_DURATION.toLong())
                }
                mTodayAnimator?.start()
            }
        }
        sendAccessibilityEventAsNeeded(false)
    }

    // Called from animation framework via reflection. Do not remove
    fun setViewStartY(viewStartY: Int) {
        var viewStartY = viewStartY
        if (viewStartY > mMaxViewStartY) {
            viewStartY = mMaxViewStartY
        }
        mViewStartY = viewStartY
        computeFirstHour()
        invalidate()
    }

    fun setAnimateTodayAlpha(todayAlpha: Int) {
        mAnimateTodayAlpha = todayAlpha
        invalidate()
    } /* ignore isDst */

    fun getSelectedDay(): Time {
        val time = Time(mBaseDate)
        time.setJulianDay(mSelectionDay)
        time.hour = mSelectionHour

        // We ignore the "isDst" field because we want normalize() to figure
        // out the correct DST value and not adjust the selected time based
        // on the current setting of DST.
        time.normalize(true /* ignore isDst */)
        return time
    }

    fun updateTitle() {
        val start = Time(mBaseDate)
        start.normalize(true)
        val end = Time(start)
        end.monthDay += mNumDays - 1
        // Move it forward one minute so the formatter doesn't lose a day
        end.minute += 1
        end.normalize(true)
        var formatFlags: Long = DateUtils.FORMAT_SHOW_DATE.toLong() or
            DateUtils.FORMAT_SHOW_YEAR.toLong()
        if (mNumDays != 1) {
            // Don't show day of the month if for multi-day view
            formatFlags = formatFlags or DateUtils.FORMAT_NO_MONTH_DAY.toLong()

            // Abbreviate the month if showing multiple months
            if (start.month !== end.month) {
                formatFlags = formatFlags or DateUtils.FORMAT_ABBREV_MONTH.toLong()
            }
        }
        mController.sendEvent(
            this as Object?, EventType.UPDATE_TITLE, start, end, null, -1, ViewType.CURRENT,
            formatFlags, null, null
        )
    }

    /**
     * return a negative number if "time" is comes before the visible time
     * range, a positive number if "time" is after the visible time range, and 0
     * if it is in the visible time range.
     */
    fun compareToVisibleTimeRange(time: Time): Int {
        val savedHour: Int = mBaseDate!!.hour
        val savedMinute: Int = mBaseDate!!.minute
        val savedSec: Int = mBaseDate!!.second
        mBaseDate!!.hour = 0
        mBaseDate!!.minute = 0
        mBaseDate!!.second = 0
        if (DEBUG) {
            Log.d(TAG, "Begin " + mBaseDate.toString())
            Log.d(TAG, "Diff  " + time.toString())
        }

        // Compare beginning of range
        var diff: Int = Time.compare(time, mBaseDate)
        if (diff > 0) {
            // Compare end of range
            mBaseDate!!.monthDay += mNumDays
            mBaseDate?.normalize(true)
            diff = Time.compare(time, mBaseDate)
            if (DEBUG) Log.d(TAG, "End   " + mBaseDate.toString())
            mBaseDate!!.monthDay -= mNumDays
            mBaseDate?.normalize(true)
            if (diff < 0) {
                // in visible time
                diff = 0
            } else if (diff == 0) {
                // Midnight of following day
                diff = 1
            }
        }
        if (DEBUG) Log.d(TAG, "Diff: $diff")
        mBaseDate!!.hour = savedHour
        mBaseDate!!.minute = savedMinute
        mBaseDate!!.second = savedSec
        return diff
    }

    private fun recalc() {
        // Set the base date to the beginning of the week if we are displaying
        // 7 days at a time.
        if (mNumDays == 7) {
            adjustToBeginningOfWeek(mBaseDate)
        }
        val start: Long = mBaseDate!!.toMillis(false /* use isDst */)
        mFirstJulianDay = Time.getJulianDay(start, mBaseDate!!.gmtoff)
        mLastJulianDay = mFirstJulianDay + mNumDays - 1
        mMonthLength = mBaseDate!!.getActualMaximum(Time.MONTH_DAY)
        mFirstVisibleDate = mBaseDate!!.monthDay
        mFirstVisibleDayOfWeek = mBaseDate!!.weekDay
    }

    private fun adjustToBeginningOfWeek(time: Time?) {
        val dayOfWeek: Int = time!!.weekDay
        var diff = dayOfWeek - mFirstDayOfWeek
        if (diff != 0) {
            if (diff < 0) {
                diff += 7
            }
            time.monthDay -= diff
            time.normalize(true /* ignore isDst */)
        }
    }

    @Override
    protected override fun onSizeChanged(width: Int, height: Int, oldw: Int, oldh: Int) {
        mViewWidth = width
        mViewHeight = height
        mEdgeEffectTop.setSize(mViewWidth, mViewHeight)
        mEdgeEffectBottom.setSize(mViewWidth, mViewHeight)
        val gridAreaWidth = width - mHoursWidth
        mCellWidth = (gridAreaWidth - mNumDays * DAY_GAP) / mNumDays

        // This would be about 1 day worth in a 7 day view
        mHorizontalSnapBackThreshold = width / 7
        val p = Paint()
        p.setTextSize(HOURS_TEXT_SIZE)
        mHoursTextHeight = Math.abs(p.ascent()).toInt()
        remeasure(width, height)
    }

    /**
     * Measures the space needed for various parts of the view after
     * loading new events.  This can change if there are all-day events.
     */
    private fun remeasure(width: Int, height: Int) {
        // Shrink to fit available space but make sure we can display at least two events
        MAX_UNEXPANDED_ALLDAY_HEIGHT = (MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT * 4).toInt()
        MAX_UNEXPANDED_ALLDAY_HEIGHT = Math.min(MAX_UNEXPANDED_ALLDAY_HEIGHT, height / 6)
        MAX_UNEXPANDED_ALLDAY_HEIGHT = Math.max(
            MAX_UNEXPANDED_ALLDAY_HEIGHT,
            MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT.toInt() * 2
        )
        mMaxUnexpandedAlldayEventCount =
            (MAX_UNEXPANDED_ALLDAY_HEIGHT / MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT).toInt()

        // First, clear the array of earliest start times, and the array
        // indicating presence of an all-day event.
        for (day in 0 until mNumDays) {
            mEarliestStartHour!![day] = 25 // some big number
            mHasAllDayEvent!![day] = false
        }
        val maxAllDayEvents = mMaxAlldayEvents

        // The min is where 24 hours cover the entire visible area
        mMinCellHeight = Math.max((height - DAY_HEADER_HEIGHT) / 24, MIN_EVENT_HEIGHT.toInt())
        if (mCellHeight < mMinCellHeight) {
            mCellHeight = mMinCellHeight
        }

        // Calculate mAllDayHeight
        mFirstCell = DAY_HEADER_HEIGHT
        var allDayHeight = 0
        if (maxAllDayEvents > 0) {
            val maxAllAllDayHeight = height - DAY_HEADER_HEIGHT - MIN_HOURS_HEIGHT
            // If there is at most one all-day event per day, then use less
            // space (but more than the space for a single event).
            if (maxAllDayEvents == 1) {
                allDayHeight = SINGLE_ALLDAY_HEIGHT
            } else if (maxAllDayEvents <= mMaxUnexpandedAlldayEventCount) {
                // Allow the all-day area to grow in height depending on the
                // number of all-day events we need to show, up to a limit.
                allDayHeight = maxAllDayEvents * MAX_HEIGHT_OF_ONE_ALLDAY_EVENT
                if (allDayHeight > MAX_UNEXPANDED_ALLDAY_HEIGHT) {
                    allDayHeight = MAX_UNEXPANDED_ALLDAY_HEIGHT
                }
            } else {
                // if we have more than the magic number, check if we're animating
                // and if not adjust the sizes appropriately
                if (mAnimateDayHeight != 0) {
                    // Don't shrink the space past the final allDay space. The animation
                    // continues to hide the last event so the more events text can
                    // fade in.
                    allDayHeight = Math.max(mAnimateDayHeight, MAX_UNEXPANDED_ALLDAY_HEIGHT)
                } else {
                    // Try to fit all the events in
                    allDayHeight = (maxAllDayEvents * MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT).toInt()
                    // But clip the area depending on which mode we're in
                    if (!mShowAllAllDayEvents && allDayHeight > MAX_UNEXPANDED_ALLDAY_HEIGHT) {
                        allDayHeight = (mMaxUnexpandedAlldayEventCount *
                            MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT).toInt()
                    } else if (allDayHeight > maxAllAllDayHeight) {
                        allDayHeight = maxAllAllDayHeight
                    }
                }
            }
            mFirstCell = DAY_HEADER_HEIGHT + allDayHeight + ALLDAY_TOP_MARGIN
        } else {
            mSelectionAllday = false
        }
        mAlldayHeight = allDayHeight
        mGridAreaHeight = height - mFirstCell

        // Set up the expand icon position
        val allDayIconWidth: Int = mExpandAlldayDrawable.getIntrinsicWidth()
        mExpandAllDayRect.left = Math.max(
            (mHoursWidth - allDayIconWidth) / 2,
            EVENT_ALL_DAY_TEXT_LEFT_MARGIN
        )
        mExpandAllDayRect.right = Math.min(
            mExpandAllDayRect.left + allDayIconWidth, mHoursWidth -
                EVENT_ALL_DAY_TEXT_RIGHT_MARGIN
        )
        mExpandAllDayRect.bottom = mFirstCell - EXPAND_ALL_DAY_BOTTOM_MARGIN
        mExpandAllDayRect.top = (mExpandAllDayRect.bottom -
            mExpandAlldayDrawable.getIntrinsicHeight())
        mNumHours = mGridAreaHeight / (mCellHeight + HOUR_GAP)
        mEventGeometry.setHourHeight(mCellHeight.toFloat())
        val minimumDurationMillis =
            (MIN_EVENT_HEIGHT * DateUtils.MINUTE_IN_MILLIS / (mCellHeight / 60.0f)).toLong()
        Event.computePositions(mEvents, minimumDurationMillis)

        // Compute the top of our reachable view
        mMaxViewStartY = HOUR_GAP + 24 * (mCellHeight + HOUR_GAP) - mGridAreaHeight
        if (DEBUG) {
            Log.e(TAG, "mViewStartY: $mViewStartY")
            Log.e(TAG, "mMaxViewStartY: $mMaxViewStartY")
        }
        if (mViewStartY > mMaxViewStartY) {
            mViewStartY = mMaxViewStartY
            computeFirstHour()
        }
        if (mFirstHour == -1) {
            initFirstHour()
            mFirstHourOffset = 0
        }

        // When we change the base date, the number of all-day events may
        // change and that changes the cell height.  When we switch dates,
        // we use the mFirstHourOffset from the previous view, but that may
        // be too large for the new view if the cell height is smaller.
        if (mFirstHourOffset >= mCellHeight + HOUR_GAP) {
            mFirstHourOffset = mCellHeight + HOUR_GAP - 1
        }
        mViewStartY = mFirstHour * (mCellHeight + HOUR_GAP) - mFirstHourOffset
        val eventAreaWidth = mNumDays * (mCellWidth + DAY_GAP)
        // When we get new events we don't want to dismiss the popup unless the event changes
        if (mSelectedEvent != null && mLastPopupEventID != mSelectedEvent!!.id) {
            mPopup?.dismiss()
        }
        mPopup?.setWidth(eventAreaWidth - 20)
        mPopup?.setHeight(WindowManager.LayoutParams.WRAP_CONTENT)
    }

    /**
     * Initialize the state for another view.  The given view is one that has
     * its own bitmap and will use an animation to replace the current view.
     * The current view and new view are either both Week views or both Day
     * views.  They differ in their base date.
     *
     * @param view the view to initialize.
     */
    private fun initView(view: DayView) {
        view.setSelectedHour(mSelectionHour)
        view.mSelectedEvents.clear()
        view.mComputeSelectedEvents = true
        view.mFirstHour = mFirstHour
        view.mFirstHourOffset = mFirstHourOffset
        view.remeasure(getWidth(), getHeight())
        view.initAllDayHeights()
        view.setSelectedEvent(null)
        view.mPrevSelectedEvent = null
        view.mFirstDayOfWeek = mFirstDayOfWeek
        if (view.mEvents.size > 0) {
            view.mSelectionAllday = mSelectionAllday
        } else {
            view.mSelectionAllday = false
        }

        // Redraw the screen so that the selection box will be redrawn.  We may
        // have scrolled to a different part of the day in some other view
        // so the selection box in this view may no longer be visible.
        view.recalc()
    }

    /**
     * Switch to another view based on what was selected (an event or a free
     * slot) and how it was selected (by touch or by trackball).
     *
     * @param trackBallSelection true if the selection was made using the
     * trackball.
     */
    private fun switchViews(trackBallSelection: Boolean) {
        val selectedEvent: Event? = mSelectedEvent
        mPopup?.dismiss()
        mLastPopupEventID = INVALID_EVENT_ID
        if (mNumDays > 1) {
            // This is the Week view.
            // With touch, we always switch to Day/Agenda View
            // With track ball, if we selected a free slot, then create an event.
            // If we selected a specific event, switch to EventInfo view.
            if (trackBallSelection) {
                if (selectedEvent != null) {
                    if (mIsAccessibilityEnabled) {
                        mAccessibilityMgr?.interrupt()
                    }
                }
            }
        }
    }

    @Override
    override fun onKeyUp(keyCode: Int, event: KeyEvent?): Boolean {
        mScrolling = false
        return super.onKeyUp(keyCode, event)
    }

    @Override
    override fun onKeyDown(keyCode: Int, event: KeyEvent?): Boolean {
        return super.onKeyDown(keyCode, event)
    }

    @Override
    override fun onHoverEvent(event: MotionEvent?): Boolean {
        return true
    }

    private val isTouchExplorationEnabled: Boolean
        private get() = mIsAccessibilityEnabled && mAccessibilityMgr!!.isTouchExplorationEnabled()

    private fun sendAccessibilityEventAsNeeded(speakEvents: Boolean) {
        if (!mIsAccessibilityEnabled) {
            return
        }
        val dayChanged = mLastSelectionDayForAccessibility != mSelectionDayForAccessibility
        val hourChanged = mLastSelectionHourForAccessibility != mSelectionHourForAccessibility
        if (dayChanged || hourChanged || mLastSelectedEventForAccessibility !==
            mSelectedEventForAccessibility) {
            mLastSelectionDayForAccessibility = mSelectionDayForAccessibility
            mLastSelectionHourForAccessibility = mSelectionHourForAccessibility
            mLastSelectedEventForAccessibility = mSelectedEventForAccessibility
            val b = StringBuilder()

            // Announce only the changes i.e. day or hour or both
            if (dayChanged) {
                b.append(selectedTimeForAccessibility.format("%A "))
            }
            if (hourChanged) {
                b.append(selectedTimeForAccessibility.format(if (mIs24HourFormat) "%k" else "%l%p"))
            }
            if (dayChanged || hourChanged) {
                b.append(PERIOD_SPACE)
            }
            if (speakEvents) {
                if (mEventCountTemplate == null) {
                    mEventCountTemplate = mContext?.getString(R.string.template_announce_item_index)
                }

                // Read out the relevant event(s)
                val numEvents: Int = mSelectedEvents.size
                if (numEvents > 0) {
                    if (mSelectedEventForAccessibility == null) {
                        // Read out all the events
                        var i = 1
                        for (calEvent in mSelectedEvents) {
                            if (numEvents > 1) {
                                // Read out x of numEvents if there are more than one event
                                mStringBuilder.setLength(0)
                                b.append(mFormatter.format(mEventCountTemplate, i++, numEvents))
                                b.append(" ")
                            }
                            appendEventAccessibilityString(b, calEvent)
                        }
                    } else {
                        if (numEvents > 1) {
                            // Read out x of numEvents if there are more than one event
                            mStringBuilder.setLength(0)
                            b.append(
                                mFormatter.format(
                                    mEventCountTemplate, mSelectedEvents
                                        .indexOf(mSelectedEventForAccessibility) + 1, numEvents
                                )
                            )
                            b.append(" ")
                        }
                        appendEventAccessibilityString(b, mSelectedEventForAccessibility)
                    }
                }
            }
            if (dayChanged || hourChanged || speakEvents) {
                val event: AccessibilityEvent = AccessibilityEvent
                    .obtain(AccessibilityEvent.TYPE_VIEW_FOCUSED)
                val msg: CharSequence = b.toString()
                event.getText().add(msg)
                event.setAddedCount(msg.length)
                sendAccessibilityEventUnchecked(event)
            }
        }
    }

    /**
     * @param b
     * @param calEvent
     */
    private fun appendEventAccessibilityString(b: StringBuilder, calEvent: Event?) {
        b.append(calEvent!!.titleAndLocation)
        b.append(PERIOD_SPACE)
        val `when`: String?
        var flags: Int = DateUtils.FORMAT_SHOW_DATE
        if (calEvent.allDay) {
            flags = flags or (DateUtils.FORMAT_UTC or DateUtils.FORMAT_SHOW_WEEKDAY)
        } else {
            flags = flags or DateUtils.FORMAT_SHOW_TIME
            if (DateFormat.is24HourFormat(mContext)) {
                flags = flags or DateUtils.FORMAT_24HOUR
            }
        }
        `when` = Utils.formatDateRange(mContext, calEvent.startMillis, calEvent.endMillis,
            flags)
        b.append(`when`)
        b.append(PERIOD_SPACE)
    }

    private inner class GotoBroadcaster(start: Time, end: Time) : Animation.AnimationListener {
        private val mCounter: Int
        private val mStart: Time
        private val mEnd: Time
        @Override
        override fun onAnimationEnd(animation: Animation) {
            var view = mViewSwitcher.getCurrentView() as DayView
            view.mViewStartX = 0
            view = mViewSwitcher.getNextView() as DayView
            view.mViewStartX = 0
            if (mCounter == sCounter) {
                mController.sendEvent(
                    this as Object?, EventType.GO_TO, mStart, mEnd, null, -1,
                    ViewType.CURRENT, CalendarController.EXTRA_GOTO_DATE, null, null
                )
            }
        }

        @Override
        override fun onAnimationRepeat(animation: Animation) {
        }

        @Override
        override fun onAnimationStart(animation: Animation) {
        }

        init {
            mCounter = ++sCounter
            mStart = start
            mEnd = end
        }
    }

    private fun switchViews(forward: Boolean, xOffSet: Float, width: Float, velocity: Float): View {
        mAnimationDistance = width - xOffSet
        if (DEBUG) {
            Log.d(TAG, "switchViews($forward) O:$xOffSet Dist:$mAnimationDistance")
        }
        var progress: Float = Math.abs(xOffSet) / width
        if (progress > 1.0f) {
            progress = 1.0f
        }
        val inFromXValue: Float
        val inToXValue: Float
        val outFromXValue: Float
        val outToXValue: Float
        if (forward) {
            inFromXValue = 1.0f - progress
            inToXValue = 0.0f
            outFromXValue = -progress
            outToXValue = -1.0f
        } else {
            inFromXValue = progress - 1.0f
            inToXValue = 0.0f
            outFromXValue = progress
            outToXValue = 1.0f
        }
        val start = Time(mBaseDate!!.timezone)
        start.set(mController.time as Long)
        if (forward) {
            start.monthDay += mNumDays
        } else {
            start.monthDay -= mNumDays
        }
        mController.time = start.normalize(true)
        var newSelected: Time? = start
        if (mNumDays == 7) {
            newSelected = Time(start)
            adjustToBeginningOfWeek(start)
        }
        val end = Time(start)
        end.monthDay += mNumDays - 1

        // We have to allocate these animation objects each time we switch views
        // because that is the only way to set the animation parameters.
        val inAnimation = TranslateAnimation(
            Animation.RELATIVE_TO_SELF, inFromXValue,
            Animation.RELATIVE_TO_SELF, inToXValue,
            Animation.ABSOLUTE, 0.0f,
            Animation.ABSOLUTE, 0.0f
        )
        val outAnimation = TranslateAnimation(
            Animation.RELATIVE_TO_SELF, outFromXValue,
            Animation.RELATIVE_TO_SELF, outToXValue,
            Animation.ABSOLUTE, 0.0f,
            Animation.ABSOLUTE, 0.0f
        )
        val duration = calculateDuration(width - Math.abs(xOffSet), width, velocity)
        inAnimation.setDuration(duration)
        inAnimation.setInterpolator(mHScrollInterpolator)
        outAnimation.setInterpolator(mHScrollInterpolator)
        outAnimation.setDuration(duration)
        outAnimation.setAnimationListener(GotoBroadcaster(start, end))
        mViewSwitcher.setInAnimation(inAnimation)
        mViewSwitcher.setOutAnimation(outAnimation)
        var view = mViewSwitcher.getCurrentView() as DayView
        view.cleanup()
        mViewSwitcher.showNext()
        view = mViewSwitcher.getCurrentView() as DayView
        view.setSelected(newSelected, true, false)
        view.requestFocus()
        view.reloadEvents()
        view.updateTitle()
        view.restartCurrentTimeUpdates()
        return view
    }

    // This is called after scrolling stops to move the selected hour
    // to the visible part of the screen.
    private fun resetSelectedHour() {
        if (mSelectionHour < mFirstHour + 1) {
            setSelectedHour(mFirstHour + 1)
            setSelectedEvent(null)
            mSelectedEvents.clear()
            mComputeSelectedEvents = true
        } else if (mSelectionHour > mFirstHour + mNumHours - 3) {
            setSelectedHour(mFirstHour + mNumHours - 3)
            setSelectedEvent(null)
            mSelectedEvents.clear()
            mComputeSelectedEvents = true
        }
    }

    private fun initFirstHour() {
        mFirstHour = mSelectionHour - mNumHours / 5
        if (mFirstHour < 0) {
            mFirstHour = 0
        } else if (mFirstHour + mNumHours > 24) {
            mFirstHour = 24 - mNumHours
        }
    }

    /**
     * Recomputes the first full hour that is visible on screen after the
     * screen is scrolled.
     */
    private fun computeFirstHour() {
        // Compute the first full hour that is visible on screen
        mFirstHour = (mViewStartY + mCellHeight + HOUR_GAP - 1) / (mCellHeight + HOUR_GAP)
        mFirstHourOffset = mFirstHour * (mCellHeight + HOUR_GAP) - mViewStartY
    }

    private fun adjustHourSelection() {
        if (mSelectionHour < 0) {
            setSelectedHour(0)
            if (mMaxAlldayEvents > 0) {
                mPrevSelectedEvent = null
                mSelectionAllday = true
            }
        }
        if (mSelectionHour > 23) {
            setSelectedHour(23)
        }

        // If the selected hour is at least 2 time slots from the top and
        // bottom of the screen, then don't scroll the view.
        if (mSelectionHour < mFirstHour + 1) {
            // If there are all-days events for the selected day but there
            // are no more normal events earlier in the day, then jump to
            // the all-day event area.
            // Exception 1: allow the user to scroll to 8am with the trackball
            // before jumping to the all-day event area.
            // Exception 2: if 12am is on screen, then allow the user to select
            // 12am before going up to the all-day event area.
            val daynum = mSelectionDay - mFirstJulianDay
            if (daynum < mEarliestStartHour!!.size && daynum >= 0 && mMaxAlldayEvents > 0 &&
                mEarliestStartHour!![daynum] > mSelectionHour &&
                mFirstHour > 0 && mFirstHour < 8) {
                mPrevSelectedEvent = null
                mSelectionAllday = true
                setSelectedHour(mFirstHour + 1)
                return
            }
            if (mFirstHour > 0) {
                mFirstHour -= 1
                mViewStartY -= mCellHeight + HOUR_GAP
                if (mViewStartY < 0) {
                    mViewStartY = 0
                }
                return
            }
        }
        if (mSelectionHour > mFirstHour + mNumHours - 3) {
            if (mFirstHour < 24 - mNumHours) {
                mFirstHour += 1
                mViewStartY += mCellHeight + HOUR_GAP
                if (mViewStartY > mMaxViewStartY) {
                    mViewStartY = mMaxViewStartY
                }
                return
            } else if (mFirstHour == 24 - mNumHours && mFirstHourOffset > 0) {
                mViewStartY = mMaxViewStartY
            }
        }
    }

    fun clearCachedEvents() {
        mLastReloadMillis = 0
    }

    private val mCancelCallback: Runnable = object : Runnable {
        override fun run() {
            clearCachedEvents()
        }
    }

    /* package */
    fun reloadEvents() {
        // Protect against this being called before this view has been
        // initialized.
//        if (mContext == null) {
//            return;
//        }

        // Make sure our time zones are up to date
        mTZUpdater.run()
        setSelectedEvent(null)
        mPrevSelectedEvent = null
        mSelectedEvents.clear()

        // The start date is the beginning of the week at 12am
        val weekStart = Time(Utils.getTimeZone(mContext, mTZUpdater))
        weekStart.set(mBaseDate)
        weekStart.hour = 0
        weekStart.minute = 0
        weekStart.second = 0
        val millis: Long = weekStart.normalize(true /* ignore isDst */)

        // Avoid reloading events unnecessarily.
        if (millis == mLastReloadMillis) {
            return
        }
        mLastReloadMillis = millis

        // load events in the background
        // mContext.startProgressSpinner();
        val events: ArrayList<Event> = ArrayList<Event>()
        mEventLoader.loadEventsInBackground(mNumDays, events as ArrayList<Event?>, mFirstJulianDay,
            object : Runnable {
            override fun run() {
                val fadeinEvents = mFirstJulianDay != mLoadedFirstJulianDay
                mEvents = events
                mLoadedFirstJulianDay = mFirstJulianDay
                if (mAllDayEvents == null) {
                    mAllDayEvents = ArrayList<Event>()
                } else {
                    mAllDayEvents?.clear()
                }

                // Create a shorter array for all day events
                for (e in events) {
                    if (e.drawAsAllday()) {
                        mAllDayEvents?.add(e)
                    }
                }

                // New events, new layouts
                if (mLayouts == null || mLayouts!!.size < events.size) {
                    mLayouts = arrayOfNulls<StaticLayout>(events.size)
                } else {
                    Arrays.fill(mLayouts, null)
                }
                if (mAllDayLayouts == null || mAllDayLayouts!!.size < mAllDayEvents!!.size) {
                    mAllDayLayouts = arrayOfNulls<StaticLayout>(events.size)
                } else {
                    Arrays.fill(mAllDayLayouts, null)
                }
                computeEventRelations()
                mRemeasure = true
                mComputeSelectedEvents = true
                recalc()

                // Start animation to cross fade the events
                if (fadeinEvents) {
                    if (mEventsCrossFadeAnimation == null) {
                        mEventsCrossFadeAnimation =
                            ObjectAnimator.ofInt(this@DayView, "EventsAlpha", 0, 255)
                        mEventsCrossFadeAnimation?.setDuration(EVENTS_CROSS_FADE_DURATION.toLong())
                    }
                    mEventsCrossFadeAnimation?.start()
                } else {
                    invalidate()
                }
            }
        }, mCancelCallback)
    }

    var eventsAlpha: Int
        get() = mEventsAlpha
        set(alpha) {
            mEventsAlpha = alpha
            invalidate()
        }

    fun stopEventsAnimation() {
        if (mEventsCrossFadeAnimation != null) {
            mEventsCrossFadeAnimation?.cancel()
        }
        mEventsAlpha = 255
    }

    private fun computeEventRelations() {
        // Compute the layout relation between each event before measuring cell
        // width, as the cell width should be adjusted along with the relation.
        //
        // Examples: A (1:00pm - 1:01pm), B (1:02pm - 2:00pm)
        // We should mark them as "overwapped". Though they are not overwapped logically, but
        // minimum cell height implicitly expands the cell height of A and it should look like
        // (1:00pm - 1:15pm) after the cell height adjustment.

        // Compute the space needed for the all-day events, if any.
        // Make a pass over all the events, and keep track of the maximum
        // number of all-day events in any one day.  Also, keep track of
        // the earliest event in each day.
        var maxAllDayEvents = 0
        val events: ArrayList<Event> = mEvents
        val len: Int = events.size
        // Num of all-day-events on each day.
        val eventsCount = IntArray(mLastJulianDay - mFirstJulianDay + 1)
        Arrays.fill(eventsCount, 0)
        for (ii in 0 until len) {
            val event: Event = events.get(ii)
            if (event.startDay > mLastJulianDay || event.endDay < mFirstJulianDay) {
                continue
            }
            if (event.drawAsAllday()) {
                // Count all the events being drawn as allDay events
                val firstDay: Int = Math.max(event.startDay, mFirstJulianDay)
                val lastDay: Int = Math.min(event.endDay, mLastJulianDay)
                for (day in firstDay..lastDay) {
                    val count = ++eventsCount[day - mFirstJulianDay]
                    if (maxAllDayEvents < count) {
                        maxAllDayEvents = count
                    }
                }
                var daynum: Int = event.startDay - mFirstJulianDay
                var durationDays: Int = event.endDay - event.startDay + 1
                if (daynum < 0) {
                    durationDays += daynum
                    daynum = 0
                }
                if (daynum + durationDays > mNumDays) {
                    durationDays = mNumDays - daynum
                }
                var day = daynum
                while (durationDays > 0) {
                    mHasAllDayEvent!![day] = true
                    day++
                    durationDays--
                }
            } else {
                var daynum: Int = event.startDay - mFirstJulianDay
                var hour: Int = event.startTime / 60
                if (daynum >= 0 && hour < mEarliestStartHour!![daynum]) {
                    mEarliestStartHour!![daynum] = hour
                }

                // Also check the end hour in case the event spans more than
                // one day.
                daynum = event.endDay - mFirstJulianDay
                hour = event.endTime / 60
                if (daynum < mNumDays && hour < mEarliestStartHour!![daynum]) {
                    mEarliestStartHour!![daynum] = hour
                }
            }
        }
        mMaxAlldayEvents = maxAllDayEvents
        initAllDayHeights()
    }

    @Override
    protected override fun onDraw(canvas: Canvas) {
        if (mRemeasure) {
            remeasure(getWidth(), getHeight())
            mRemeasure = false
        }
        canvas.save()
        val yTranslate = (-mViewStartY + DAY_HEADER_HEIGHT + mAlldayHeight).toFloat()
        // offset canvas by the current drag and header position
        canvas.translate(-mViewStartX.toFloat(), yTranslate)
        // clip to everything below the allDay area
        val dest: Rect = mDestRect
        dest.top = (mFirstCell - yTranslate).toInt()
        dest.bottom = (mViewHeight - yTranslate).toInt()
        dest.left = 0
        dest.right = mViewWidth
        canvas.save()
        canvas.clipRect(dest)
        // Draw the movable part of the view
        doDraw(canvas)
        // restore to having no clip
        canvas.restore()
        if (mTouchMode and TOUCH_MODE_HSCROLL != 0) {
            val xTranslate: Float
            xTranslate = if (mViewStartX > 0) {
                mViewWidth.toFloat()
            } else {
                -mViewWidth.toFloat()
            }
            // Move the canvas around to prep it for the next view
            // specifically, shift it by a screen and undo the
            // yTranslation which will be redone in the nextView's onDraw().
            canvas.translate(xTranslate, -yTranslate)
            val nextView = mViewSwitcher.getNextView() as DayView

            // Prevent infinite recursive calls to onDraw().
            nextView.mTouchMode = TOUCH_MODE_INITIAL_STATE
            nextView.onDraw(canvas)
            // Move it back for this view
            canvas.translate(-xTranslate, 0f)
        } else {
            // If we drew another view we already translated it back
            // If we didn't draw another view we should be at the edge of the
            // screen
            canvas.translate(mViewStartX.toFloat(), -yTranslate)
        }

        // Draw the fixed areas (that don't scroll) directly to the canvas.
        drawAfterScroll(canvas)
        if (mComputeSelectedEvents && mUpdateToast) {
            mUpdateToast = false
        }
        mComputeSelectedEvents = false

        // Draw overscroll glow
        if (!mEdgeEffectTop.isFinished()) {
            if (DAY_HEADER_HEIGHT != 0) {
                canvas.translate(0f, DAY_HEADER_HEIGHT.toFloat())
            }
            if (mEdgeEffectTop.draw(canvas)) {
                invalidate()
            }
            if (DAY_HEADER_HEIGHT != 0) {
                canvas.translate(0f, -DAY_HEADER_HEIGHT.toFloat())
            }
        }
        if (!mEdgeEffectBottom.isFinished()) {
            canvas.rotate(180f, mViewWidth.toFloat() / 2f, mViewHeight.toFloat() / 2f)
            if (mEdgeEffectBottom.draw(canvas)) {
                invalidate()
            }
        }
        canvas.restore()
    }

    private fun drawAfterScroll(canvas: Canvas) {
        val p: Paint = mPaint
        val r: Rect = mRect
        drawAllDayHighlights(r, canvas, p)
        if (mMaxAlldayEvents != 0) {
            drawAllDayEvents(mFirstJulianDay, mNumDays, canvas, p)
            drawUpperLeftCorner(r, canvas, p)
        }
        drawScrollLine(r, canvas, p)
        drawDayHeaderLoop(r, canvas, p)

        // Draw the AM and PM indicators if we're in 12 hour mode
        if (!mIs24HourFormat) {
            drawAmPm(canvas, p)
        }
    }

    // This isn't really the upper-left corner. It's the square area just
    // below the upper-left corner, above the hours and to the left of the
    // all-day area.
    private fun drawUpperLeftCorner(r: Rect, canvas: Canvas, p: Paint) {
        setupHourTextPaint(p)
        if (mMaxAlldayEvents > mMaxUnexpandedAlldayEventCount) {
            // Draw the allDay expand/collapse icon
            if (mUseExpandIcon) {
                mExpandAlldayDrawable.setBounds(mExpandAllDayRect)
                mExpandAlldayDrawable.draw(canvas)
            } else {
                mCollapseAlldayDrawable.setBounds(mExpandAllDayRect)
                mCollapseAlldayDrawable.draw(canvas)
            }
        }
    }

    private fun drawScrollLine(r: Rect, canvas: Canvas, p: Paint) {
        val right = computeDayLeftPosition(mNumDays)
        val y = mFirstCell - 1
        p.setAntiAlias(false)
        p.setStyle(Style.FILL)
        p.setColor(mCalendarGridLineInnerHorizontalColor)
        p.setStrokeWidth(GRID_LINE_INNER_WIDTH)
        canvas.drawLine(GRID_LINE_LEFT_MARGIN, y.toFloat(), right.toFloat(), y.toFloat(), p)
        p.setAntiAlias(true)
    }

    // Computes the x position for the left side of the given day (base 0)
    private fun computeDayLeftPosition(day: Int): Int {
        val effectiveWidth = mViewWidth - mHoursWidth
        return day * effectiveWidth / mNumDays + mHoursWidth
    }

    private fun drawAllDayHighlights(r: Rect, canvas: Canvas, p: Paint) {
        if (mFutureBgColor != 0) {
            // First, color the labels area light gray
            r.top = 0
            r.bottom = DAY_HEADER_HEIGHT
            r.left = 0
            r.right = mViewWidth
            p.setColor(mBgColor)
            p.setStyle(Style.FILL)
            canvas.drawRect(r, p)
            // and the area that says All day
            r.top = DAY_HEADER_HEIGHT
            r.bottom = mFirstCell - 1
            r.left = 0
            r.right = mHoursWidth
            canvas.drawRect(r, p)
            var startIndex = -1
            val todayIndex = mTodayJulianDay - mFirstJulianDay
            if (todayIndex < 0) {
                // Future
                startIndex = 0
            } else if (todayIndex >= 1 && todayIndex + 1 < mNumDays) {
                // Multiday - tomorrow is visible.
                startIndex = todayIndex + 1
            }
            if (startIndex >= 0) {
                // Draw the future highlight
                r.top = 0
                r.bottom = mFirstCell - 1
                r.left = computeDayLeftPosition(startIndex) + 1
                r.right = computeDayLeftPosition(mNumDays)
                p.setColor(mFutureBgColor)
                p.setStyle(Style.FILL)
                canvas.drawRect(r, p)
            }
        }
    }

    private fun drawDayHeaderLoop(r: Rect, canvas: Canvas, p: Paint) {
        // Draw the horizontal day background banner
        // p.setColor(mCalendarDateBannerBackground);
        // r.top = 0;
        // r.bottom = DAY_HEADER_HEIGHT;
        // r.left = 0;
        // r.right = mHoursWidth + mNumDays * (mCellWidth + DAY_GAP);
        // canvas.drawRect(r, p);
        //
        // Fill the extra space on the right side with the default background
        // r.left = r.right;
        // r.right = mViewWidth;
        // p.setColor(mCalendarGridAreaBackground);
        // canvas.drawRect(r, p);
        if (mNumDays == 1 && ONE_DAY_HEADER_HEIGHT == 0) {
            return
        }
        p.setTypeface(mBold)
        p.setTextAlign(Paint.Align.RIGHT)
        var cell = mFirstJulianDay
        val dayNames: Array<String?>?
        dayNames = if (mDateStrWidth < mCellWidth) {
            mDayStrs
        } else {
            mDayStrs2Letter
        }
        p.setAntiAlias(true)
        var day = 0
        while (day < mNumDays) {
            var dayOfWeek = day + mFirstVisibleDayOfWeek
            if (dayOfWeek >= 14) {
                dayOfWeek -= 14
            }
            var color = mCalendarDateBannerTextColor
            if (mNumDays == 1) {
                if (dayOfWeek == Time.SATURDAY) {
                    color = mWeek_saturdayColor
                } else if (dayOfWeek == Time.SUNDAY) {
                    color = mWeek_sundayColor
                }
            } else {
                val column = day % 7
                if (Utils.isSaturday(column, mFirstDayOfWeek)) {
                    color = mWeek_saturdayColor
                } else if (Utils.isSunday(column, mFirstDayOfWeek)) {
                    color = mWeek_sundayColor
                }
            }
            p.setColor(color)
            drawDayHeader(dayNames!![dayOfWeek], day, cell, canvas, p)
            day++
            cell++
        }
        p.setTypeface(null)
    }

    private fun drawAmPm(canvas: Canvas, p: Paint) {
        p.setColor(mCalendarAmPmLabel)
        p.setTextSize(AMPM_TEXT_SIZE)
        p.setTypeface(mBold)
        p.setAntiAlias(true)
        p.setTextAlign(Paint.Align.RIGHT)
        var text = mAmString
        if (mFirstHour >= 12) {
            text = mPmString
        }
        var y = mFirstCell + mFirstHourOffset + 2 * mHoursTextHeight + HOUR_GAP
        canvas.drawText(text as String, HOURS_LEFT_MARGIN.toFloat(), y.toFloat(), p)
        if (mFirstHour < 12 && mFirstHour + mNumHours > 12) {
            // Also draw the "PM"
            text = mPmString
            y =
                mFirstCell + mFirstHourOffset + (12 - mFirstHour) * (mCellHeight + HOUR_GAP) +
                    2 * mHoursTextHeight + HOUR_GAP
            canvas.drawText(text as String, HOURS_LEFT_MARGIN.toFloat(), y.toFloat(), p)
        }
    }

    private fun drawCurrentTimeLine(
        r: Rect,
        day: Int,
        top: Int,
        canvas: Canvas,
        p: Paint
    ) {
        r.left = computeDayLeftPosition(day) - CURRENT_TIME_LINE_SIDE_BUFFER + 1
        r.right = computeDayLeftPosition(day + 1) + CURRENT_TIME_LINE_SIDE_BUFFER + 1
        r.top = top - CURRENT_TIME_LINE_TOP_OFFSET
        r.bottom = r.top + mCurrentTimeLine.getIntrinsicHeight()
        mCurrentTimeLine.setBounds(r)
        mCurrentTimeLine.draw(canvas)
        if (mAnimateToday) {
            mCurrentTimeAnimateLine.setBounds(r)
            mCurrentTimeAnimateLine.setAlpha(mAnimateTodayAlpha)
            mCurrentTimeAnimateLine.draw(canvas)
        }
    }

    private fun doDraw(canvas: Canvas) {
        val p: Paint = mPaint
        val r: Rect = mRect
        if (mFutureBgColor != 0) {
            drawBgColors(r, canvas, p)
        }
        drawGridBackground(r, canvas, p)
        drawHours(r, canvas, p)

        // Draw each day
        var cell = mFirstJulianDay
        p.setAntiAlias(false)
        val alpha: Int = p.getAlpha()
        p.setAlpha(mEventsAlpha)
        var day = 0
        while (day < mNumDays) {

            // TODO Wow, this needs cleanup. drawEvents loop through all the
            // events on every call.
            drawEvents(cell, day, HOUR_GAP, canvas, p)
            // If this is today
            if (cell == mTodayJulianDay) {
                val lineY: Int =
                    mCurrentTime!!.hour * (mCellHeight + HOUR_GAP) + mCurrentTime!!.minute *
                        mCellHeight / 60 + 1

                // And the current time shows up somewhere on the screen
                if (lineY >= mViewStartY && lineY < mViewStartY + mViewHeight - 2) {
                    drawCurrentTimeLine(r, day, lineY, canvas, p)
                }
            }
            day++
            cell++
        }
        p.setAntiAlias(true)
        p.setAlpha(alpha)
    }

    private fun drawHours(r: Rect, canvas: Canvas, p: Paint) {
        setupHourTextPaint(p)
        var y = HOUR_GAP + mHoursTextHeight + HOURS_TOP_MARGIN
        for (i in 0..23) {
            val time = mHourStrs!![i]
            canvas.drawText(time, HOURS_LEFT_MARGIN.toFloat(), y.toFloat(), p)
            y += mCellHeight + HOUR_GAP
        }
    }

    private fun setupHourTextPaint(p: Paint) {
        p.setColor(mCalendarHourLabelColor)
        p.setTextSize(HOURS_TEXT_SIZE)
        p.setTypeface(Typeface.DEFAULT)
        p.setTextAlign(Paint.Align.RIGHT)
        p.setAntiAlias(true)
    }

    private fun drawDayHeader(dayStr: String?, day: Int, cell: Int, canvas: Canvas, p: Paint) {
        var dateNum = mFirstVisibleDate + day
        var x: Int
        if (dateNum > mMonthLength) {
            dateNum -= mMonthLength
        }
        p.setAntiAlias(true)
        val todayIndex = mTodayJulianDay - mFirstJulianDay
        // Draw day of the month
        val dateNumStr: String = dateNum.toString()
        if (mNumDays > 1) {
            val y = (DAY_HEADER_HEIGHT - DAY_HEADER_BOTTOM_MARGIN).toFloat()

            // Draw day of the month
            x = computeDayLeftPosition(day + 1) - DAY_HEADER_RIGHT_MARGIN
            p.setTextAlign(Align.RIGHT)
            p.setTextSize(DATE_HEADER_FONT_SIZE)
            p.setTypeface(if (todayIndex == day) mBold else Typeface.DEFAULT)
            canvas.drawText(dateNumStr as String, x.toFloat(), y, p)

            // Draw day of the week
            x -= (p.measureText(" $dateNumStr")).toInt()
            p.setTextSize(DAY_HEADER_FONT_SIZE)
            p.setTypeface(Typeface.DEFAULT)
            canvas.drawText(dayStr as String, x.toFloat(), y, p)
        } else {
            val y = (ONE_DAY_HEADER_HEIGHT - DAY_HEADER_ONE_DAY_BOTTOM_MARGIN).toFloat()
            p.setTextAlign(Align.LEFT)

            // Draw day of the week
            x = computeDayLeftPosition(day) + DAY_HEADER_ONE_DAY_LEFT_MARGIN
            p.setTextSize(DAY_HEADER_FONT_SIZE)
            p.setTypeface(Typeface.DEFAULT)
            canvas.drawText(dayStr as String, x.toFloat(), y, p)

            // Draw day of the month
            x += (p.measureText(dayStr) + DAY_HEADER_ONE_DAY_RIGHT_MARGIN).toInt()
            p.setTextSize(DATE_HEADER_FONT_SIZE)
            p.setTypeface(if (todayIndex == day) mBold else Typeface.DEFAULT)
            canvas.drawText(dateNumStr, x.toFloat(), y, p)
        }
    }

    private fun drawGridBackground(r: Rect, canvas: Canvas, p: Paint) {
        val savedStyle: Style = p.getStyle()
        val stopX = computeDayLeftPosition(mNumDays).toFloat()
        var y = 0f
        val deltaY = (mCellHeight + HOUR_GAP).toFloat()
        var linesIndex = 0
        val startY = 0f
        val stopY = (HOUR_GAP + 24 * (mCellHeight + HOUR_GAP)).toFloat()
        var x = mHoursWidth.toFloat()

        // Draw the inner horizontal grid lines
        p.setColor(mCalendarGridLineInnerHorizontalColor)
        p.setStrokeWidth(GRID_LINE_INNER_WIDTH)
        p.setAntiAlias(false)
        y = 0f
        linesIndex = 0
        for (hour in 0..24) {
            mLines[linesIndex++] = GRID_LINE_LEFT_MARGIN
            mLines[linesIndex++] = y
            mLines[linesIndex++] = stopX
            mLines[linesIndex++] = y
            y += deltaY
        }
        if (mCalendarGridLineInnerVerticalColor != mCalendarGridLineInnerHorizontalColor) {
            canvas.drawLines(mLines, 0, linesIndex, p)
            linesIndex = 0
            p.setColor(mCalendarGridLineInnerVerticalColor)
        }

        // Draw the inner vertical grid lines
        for (day in 0..mNumDays) {
            x = computeDayLeftPosition(day).toFloat()
            mLines[linesIndex++] = x
            mLines[linesIndex++] = startY
            mLines[linesIndex++] = x
            mLines[linesIndex++] = stopY
        }
        canvas.drawLines(mLines, 0, linesIndex, p)

        // Restore the saved style.
        p.setStyle(savedStyle)
        p.setAntiAlias(true)
    }

    /**
     * @param r
     * @param canvas
     * @param p
     */
    private fun drawBgColors(r: Rect, canvas: Canvas, p: Paint) {
        val todayIndex = mTodayJulianDay - mFirstJulianDay
        // Draw the hours background color
        r.top = mDestRect.top
        r.bottom = mDestRect.bottom
        r.left = 0
        r.right = mHoursWidth
        p.setColor(mBgColor)
        p.setStyle(Style.FILL)
        p.setAntiAlias(false)
        canvas.drawRect(r, p)

        // Draw background for grid area
        if (mNumDays == 1 && todayIndex == 0) {
            // Draw a white background for the time later than current time
            var lineY: Int =
                mCurrentTime!!.hour * (mCellHeight + HOUR_GAP) + mCurrentTime!!.minute *
                    mCellHeight / 60 + 1
            if (lineY < mViewStartY + mViewHeight) {
                lineY = Math.max(lineY, mViewStartY)
                r.left = mHoursWidth
                r.right = mViewWidth
                r.top = lineY
                r.bottom = mViewStartY + mViewHeight
                p.setColor(mFutureBgColor)
                canvas.drawRect(r, p)
            }
        } else if (todayIndex >= 0 && todayIndex < mNumDays) {
            // Draw today with a white background for the time later than current time
            var lineY: Int =
                mCurrentTime!!.hour * (mCellHeight + HOUR_GAP) + mCurrentTime!!.minute *
                    mCellHeight / 60 + 1
            if (lineY < mViewStartY + mViewHeight) {
                lineY = Math.max(lineY, mViewStartY)
                r.left = computeDayLeftPosition(todayIndex) + 1
                r.right = computeDayLeftPosition(todayIndex + 1)
                r.top = lineY
                r.bottom = mViewStartY + mViewHeight
                p.setColor(mFutureBgColor)
                canvas.drawRect(r, p)
            }

            // Paint Tomorrow and later days with future color
            if (todayIndex + 1 < mNumDays) {
                r.left = computeDayLeftPosition(todayIndex + 1) + 1
                r.right = computeDayLeftPosition(mNumDays)
                r.top = mDestRect.top
                r.bottom = mDestRect.bottom
                p.setColor(mFutureBgColor)
                canvas.drawRect(r, p)
            }
        } else if (todayIndex < 0) {
            // Future
            r.left = computeDayLeftPosition(0) + 1
            r.right = computeDayLeftPosition(mNumDays)
            r.top = mDestRect.top
            r.bottom = mDestRect.bottom
            p.setColor(mFutureBgColor)
            canvas.drawRect(r, p)
        }
        p.setAntiAlias(true)
    }

    private fun computeMaxStringWidth(currentMax: Int, strings: Array<String?>, p: Paint): Int {
        var maxWidthF = 0.0f
        val len = strings.size
        for (i in 0 until len) {
            val width: Float = p.measureText(strings[i])
            maxWidthF = Math.max(width, maxWidthF)
        }
        var maxWidth = (maxWidthF + 0.5).toInt()
        if (maxWidth < currentMax) {
            maxWidth = currentMax
        }
        return maxWidth
    }

    private fun saveSelectionPosition(left: Float, top: Float, right: Float, bottom: Float) {
        mPrevBox.left = left.toInt()
        mPrevBox.right = right.toInt()
        mPrevBox.top = top.toInt()
        mPrevBox.bottom = bottom.toInt()
    }

    private fun setupTextRect(r: Rect) {
        if (r.bottom <= r.top || r.right <= r.left) {
            r.bottom = r.top
            r.right = r.left
            return
        }
        if (r.bottom - r.top > EVENT_TEXT_TOP_MARGIN + EVENT_TEXT_BOTTOM_MARGIN) {
            r.top += EVENT_TEXT_TOP_MARGIN
            r.bottom -= EVENT_TEXT_BOTTOM_MARGIN
        }
        if (r.right - r.left > EVENT_TEXT_LEFT_MARGIN + EVENT_TEXT_RIGHT_MARGIN) {
            r.left += EVENT_TEXT_LEFT_MARGIN
            r.right -= EVENT_TEXT_RIGHT_MARGIN
        }
    }

    private fun setupAllDayTextRect(r: Rect) {
        if (r.bottom <= r.top || r.right <= r.left) {
            r.bottom = r.top
            r.right = r.left
            return
        }
        if (r.bottom - r.top > EVENT_ALL_DAY_TEXT_TOP_MARGIN + EVENT_ALL_DAY_TEXT_BOTTOM_MARGIN) {
            r.top += EVENT_ALL_DAY_TEXT_TOP_MARGIN
            r.bottom -= EVENT_ALL_DAY_TEXT_BOTTOM_MARGIN
        }
        if (r.right - r.left > EVENT_ALL_DAY_TEXT_LEFT_MARGIN + EVENT_ALL_DAY_TEXT_RIGHT_MARGIN) {
            r.left += EVENT_ALL_DAY_TEXT_LEFT_MARGIN
            r.right -= EVENT_ALL_DAY_TEXT_RIGHT_MARGIN
        }
    }

    /**
     * Return the layout for a numbered event. Create it if not already existing
     */
    private fun getEventLayout(
        layouts: Array<StaticLayout?>?,
        i: Int,
        event: Event,
        paint: Paint,
        r: Rect
    ): StaticLayout? {
        if (i < 0 || i >= layouts!!.size) {
            return null
        }
        var layout: StaticLayout? = layouts[i]
        // Check if we have already initialized the StaticLayout and that
        // the width hasn't changed (due to vertical resizing which causes
        // re-layout of events at min height)
        if (layout == null || r.width() !== layout.getWidth()) {
            val bob = SpannableStringBuilder()
            if (event.title != null) {
                // MAX - 1 since we add a space
                bob.append(drawTextSanitizer(event.title.toString(),
                    MAX_EVENT_TEXT_LEN - 1))
                bob.setSpan(StyleSpan(android.graphics.Typeface.BOLD), 0, bob.length, 0)
                bob.append(' ')
            }
            if (event.location != null) {
                bob.append(
                    drawTextSanitizer(
                        event.location.toString(),
                        MAX_EVENT_TEXT_LEN - bob.length
                    )
                )
            }
            when (event.selfAttendeeStatus) {
                Attendees.ATTENDEE_STATUS_INVITED -> paint.setColor(event.color)
                Attendees.ATTENDEE_STATUS_DECLINED -> {
                    paint.setColor(mEventTextColor)
                    paint.setAlpha(Utils.DECLINED_EVENT_TEXT_ALPHA)
                }
                Attendees.ATTENDEE_STATUS_NONE, Attendees.ATTENDEE_STATUS_ACCEPTED,
                    Attendees.ATTENDEE_STATUS_TENTATIVE -> paint.setColor(
                    mEventTextColor
                )
                else -> paint.setColor(mEventTextColor)
            }

            // Leave a one pixel boundary on the left and right of the rectangle for the event
            layout = StaticLayout(
                bob, 0, bob.length, TextPaint(paint), r.width(),
                Alignment.ALIGN_NORMAL, 1.0f, 0.0f, true, null, r.width()
            )
            layouts[i] = layout
        }
        layout.getPaint().setAlpha(mEventsAlpha)
        return layout
    }

    private fun drawAllDayEvents(firstDay: Int, numDays: Int, canvas: Canvas, p: Paint) {
        p.setTextSize(NORMAL_FONT_SIZE)
        p.setTextAlign(Paint.Align.LEFT)
        val eventTextPaint: Paint = mEventTextPaint
        val startY = DAY_HEADER_HEIGHT.toFloat()
        val stopY = startY + mAlldayHeight + ALLDAY_TOP_MARGIN
        var x = 0f
        var linesIndex = 0

        // Draw the inner vertical grid lines
        p.setColor(mCalendarGridLineInnerVerticalColor)
        x = mHoursWidth.toFloat()
        p.setStrokeWidth(GRID_LINE_INNER_WIDTH)
        // Line bounding the top of the all day area
        mLines[linesIndex++] = GRID_LINE_LEFT_MARGIN
        mLines[linesIndex++] = startY
        mLines[linesIndex++] = computeDayLeftPosition(mNumDays).toFloat()
        mLines[linesIndex++] = startY
        for (day in 0..mNumDays) {
            x = computeDayLeftPosition(day).toFloat()
            mLines[linesIndex++] = x
            mLines[linesIndex++] = startY
            mLines[linesIndex++] = x
            mLines[linesIndex++] = stopY
        }
        p.setAntiAlias(false)
        canvas.drawLines(mLines, 0, linesIndex, p)
        p.setStyle(Style.FILL)
        val y = DAY_HEADER_HEIGHT + ALLDAY_TOP_MARGIN
        val lastDay = firstDay + numDays - 1
        val events: ArrayList<Event>? = mAllDayEvents
        val numEvents: Int = events!!.size
        // Whether or not we should draw the more events text
        var hasMoreEvents = false
        // size of the allDay area
        val drawHeight = mAlldayHeight.toFloat()
        // max number of events being drawn in one day of the allday area
        var numRectangles = mMaxAlldayEvents.toFloat()
        // Where to cut off drawn allday events
        var allDayEventClip = DAY_HEADER_HEIGHT + mAlldayHeight + ALLDAY_TOP_MARGIN
        // The number of events that weren't drawn in each day
        mSkippedAlldayEvents = IntArray(numDays)
        if (mMaxAlldayEvents > mMaxUnexpandedAlldayEventCount &&
            !mShowAllAllDayEvents && mAnimateDayHeight == 0) {
            // We draw one fewer event than will fit so that more events text
            // can be drawn
            numRectangles = (mMaxUnexpandedAlldayEventCount - 1).toFloat()
            // We also clip the events above the more events text
            allDayEventClip -= MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT.toInt()
            hasMoreEvents = true
        } else if (mAnimateDayHeight != 0) {
            // clip at the end of the animating space
            allDayEventClip = DAY_HEADER_HEIGHT + mAnimateDayHeight + ALLDAY_TOP_MARGIN
        }
        var alpha: Int = eventTextPaint.getAlpha()
        eventTextPaint.setAlpha(mEventsAlpha)
        for (i in 0 until numEvents) {
            val event: Event = events.get(i)
            var startDay: Int = event.startDay
            var endDay: Int = event.endDay
            if (startDay > lastDay || endDay < firstDay) {
                continue
            }
            if (startDay < firstDay) {
                startDay = firstDay
            }
            if (endDay > lastDay) {
                endDay = lastDay
            }
            val startIndex = startDay - firstDay
            val endIndex = endDay - firstDay
            var height =
                if (mMaxAlldayEvents > mMaxUnexpandedAlldayEventCount)
                    mAnimateDayEventHeight.toFloat() else drawHeight / numRectangles

            // Prevent a single event from getting too big
            if (height > MAX_HEIGHT_OF_ONE_ALLDAY_EVENT) {
                height = MAX_HEIGHT_OF_ONE_ALLDAY_EVENT.toFloat()
            }

            // Leave a one-pixel space between the vertical day lines and the
            // event rectangle.
            event.left = computeDayLeftPosition(startIndex).toFloat()
            event.right = computeDayLeftPosition(endIndex + 1).toFloat() - DAY_GAP
            event.top = y + height * event.getColumn()
            event.bottom = event.top + height - ALL_DAY_EVENT_RECT_BOTTOM_MARGIN
            if (mMaxAlldayEvents > mMaxUnexpandedAlldayEventCount) {
                // check if we should skip this event. We skip if it starts
                // after the clip bound or ends after the skip bound and we're
                // not animating.
                if (event.top >= allDayEventClip) {
                    incrementSkipCount(mSkippedAlldayEvents, startIndex, endIndex)
                    continue
                } else if (event.bottom > allDayEventClip) {
                    if (hasMoreEvents) {
                        incrementSkipCount(mSkippedAlldayEvents, startIndex, endIndex)
                        continue
                    }
                    event.bottom = allDayEventClip.toFloat()
                }
            }
            val r: Rect = drawEventRect(
                event, canvas, p, eventTextPaint, event.top.toInt(),
                event.bottom.toInt()
            )
            setupAllDayTextRect(r)
            val layout: StaticLayout? = getEventLayout(mAllDayLayouts, i, event, eventTextPaint, r)
            drawEventText(layout, r, canvas, r.top, r.bottom, true)

            // Check if this all-day event intersects the selected day
            if (mSelectionAllday && mComputeSelectedEvents) {
                if (startDay <= mSelectionDay && endDay >= mSelectionDay) {
                    mSelectedEvents.add(event)
                }
            }
        }
        eventTextPaint.setAlpha(alpha)
        if (mMoreAlldayEventsTextAlpha != 0 && mSkippedAlldayEvents != null) {
            // If the more allday text should be visible, draw it.
            alpha = p.getAlpha()
            p.setAlpha(mEventsAlpha)
            p.setColor(mMoreAlldayEventsTextAlpha shl 24 and mMoreEventsTextColor)
            for (i in mSkippedAlldayEvents!!.indices) {
                if (mSkippedAlldayEvents!![i] > 0) {
                    drawMoreAlldayEvents(canvas, mSkippedAlldayEvents!![i], i, p)
                }
            }
            p.setAlpha(alpha)
        }
        if (mSelectionAllday) {
            // Compute the neighbors for the list of all-day events that
            // intersect the selected day.
            computeAllDayNeighbors()

            // Set the selection position to zero so that when we move down
            // to the normal event area, we will highlight the topmost event.
            saveSelectionPosition(0f, 0f, 0f, 0f)
        }
    }

    // Helper method for counting the number of allday events skipped on each day
    private fun incrementSkipCount(counts: IntArray?, startIndex: Int, endIndex: Int) {
        if (counts == null || startIndex < 0 || endIndex > counts.size) {
            return
        }
        for (i in startIndex..endIndex) {
            counts[i]++
        }
    }

    // Draws the "box +n" text for hidden allday events
    protected fun drawMoreAlldayEvents(canvas: Canvas, remainingEvents: Int, day: Int, p: Paint) {
        var x = computeDayLeftPosition(day) + EVENT_ALL_DAY_TEXT_LEFT_MARGIN
        var y = (mAlldayHeight - .5f * MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT - (.5f *
            EVENT_SQUARE_WIDTH) + DAY_HEADER_HEIGHT + ALLDAY_TOP_MARGIN).toInt()
        val r: Rect = mRect
        r.top = y
        r.left = x
        r.bottom = y + EVENT_SQUARE_WIDTH
        r.right = x + EVENT_SQUARE_WIDTH
        p.setColor(mMoreEventsTextColor)
        p.setStrokeWidth(EVENT_RECT_STROKE_WIDTH.toFloat())
        p.setStyle(Style.STROKE)
        p.setAntiAlias(false)
        canvas.drawRect(r, p)
        p.setAntiAlias(true)
        p.setStyle(Style.FILL)
        p.setTextSize(EVENT_TEXT_FONT_SIZE)
        val text: String =
            mResources.getQuantityString(R.plurals.month_more_events, remainingEvents)
        y += EVENT_SQUARE_WIDTH
        x += EVENT_SQUARE_WIDTH + EVENT_LINE_PADDING
        canvas.drawText(String.format(text, remainingEvents), x.toFloat(), y.toFloat(), p)
    }

    private fun computeAllDayNeighbors() {
        val len: Int = mSelectedEvents.size
        if (len == 0 || mSelectedEvent != null) {
            return
        }

        // First, clear all the links
        for (ii in 0 until len) {
            val ev: Event = mSelectedEvents.get(ii)
            ev.nextUp = null
            ev.nextDown = null
            ev.nextLeft = null
            ev.nextRight = null
        }

        // For each event in the selected event list "mSelectedEvents", find
        // its neighbors in the up and down directions. This could be done
        // more efficiently by sorting on the Event.getColumn() field, but
        // the list is expected to be very small.

        // Find the event in the same row as the previously selected all-day
        // event, if any.
        var startPosition = -1
        if (mPrevSelectedEvent != null && mPrevSelectedEvent!!.drawAsAllday()) {
            startPosition = mPrevSelectedEvent?.getColumn() as Int
        }
        var maxPosition = -1
        var startEvent: Event? = null
        var maxPositionEvent: Event? = null
        for (ii in 0 until len) {
            val ev: Event = mSelectedEvents.get(ii)
            val position: Int = ev.getColumn()
            if (position == startPosition) {
                startEvent = ev
            } else if (position > maxPosition) {
                maxPositionEvent = ev
                maxPosition = position
            }
            for (jj in 0 until len) {
                if (jj == ii) {
                    continue
                }
                val neighbor: Event = mSelectedEvents.get(jj)
                val neighborPosition: Int = neighbor.getColumn()
                if (neighborPosition == position - 1) {
                    ev.nextUp = neighbor
                } else if (neighborPosition == position + 1) {
                    ev.nextDown = neighbor
                }
            }
        }
        if (startEvent != null) {
            setSelectedEvent(startEvent)
        } else {
            setSelectedEvent(maxPositionEvent)
        }
    }

    private fun drawEvents(date: Int, dayIndex: Int, top: Int, canvas: Canvas, p: Paint) {
        val eventTextPaint: Paint = mEventTextPaint
        val left = computeDayLeftPosition(dayIndex) + 1
        val cellWidth = computeDayLeftPosition(dayIndex + 1) - left + 1
        val cellHeight = mCellHeight

        // Use the selected hour as the selection region
        val selectionArea: Rect = mSelectionRect
        selectionArea.top = top + mSelectionHour * (cellHeight + HOUR_GAP)
        selectionArea.bottom = selectionArea.top + cellHeight
        selectionArea.left = left
        selectionArea.right = selectionArea.left + cellWidth
        val events: ArrayList<Event> = mEvents
        val numEvents: Int = events.size
        val geometry: EventGeometry = mEventGeometry
        val viewEndY = mViewStartY + mViewHeight - DAY_HEADER_HEIGHT - mAlldayHeight
        val alpha: Int = eventTextPaint.getAlpha()
        eventTextPaint.setAlpha(mEventsAlpha)
        for (i in 0 until numEvents) {
            val event: Event = events.get(i)
            if (!geometry.computeEventRect(date, left, top, cellWidth, event)) {
                continue
            }

            // Don't draw it if it is not visible
            if (event.bottom < mViewStartY || event.top > viewEndY) {
                continue
            }
            if (date == mSelectionDay && !mSelectionAllday && mComputeSelectedEvents &&
                geometry.eventIntersectsSelection(event, selectionArea)
            ) {
                mSelectedEvents.add(event)
            }
            val r: Rect = drawEventRect(event, canvas, p, eventTextPaint, mViewStartY, viewEndY)
            setupTextRect(r)

            // Don't draw text if it is not visible
            if (r.top > viewEndY || r.bottom < mViewStartY) {
                continue
            }
            val layout: StaticLayout? = getEventLayout(mLayouts, i, event, eventTextPaint, r)
            // TODO: not sure why we are 4 pixels off
            drawEventText(
                layout,
                r,
                canvas,
                mViewStartY + 4,
                mViewStartY + mViewHeight - DAY_HEADER_HEIGHT - mAlldayHeight,
                false
            )
        }
        eventTextPaint.setAlpha(alpha)
    }

    private fun drawEventRect(
        event: Event,
        canvas: Canvas,
        p: Paint,
        eventTextPaint: Paint,
        visibleTop: Int,
        visibleBot: Int
    ): Rect {
        // Draw the Event Rect
        val r: Rect = mRect
        r.top = Math.max(event.top.toInt() + EVENT_RECT_TOP_MARGIN, visibleTop)
        r.bottom = Math.min(event.bottom.toInt() - EVENT_RECT_BOTTOM_MARGIN, visibleBot)
        r.left = event.left.toInt() + EVENT_RECT_LEFT_MARGIN
        r.right = event.right.toInt()
        var color: Int = event.color
        when (event.selfAttendeeStatus) {
            Attendees.ATTENDEE_STATUS_INVITED -> if (event !== mClickedEvent) {
                p.setStyle(Style.STROKE)
            }
            Attendees.ATTENDEE_STATUS_DECLINED -> {
                if (event !== mClickedEvent) {
                    color = Utils.getDeclinedColorFromColor(color)
                }
                p.setStyle(Style.FILL_AND_STROKE)
            }
            Attendees.ATTENDEE_STATUS_NONE, Attendees.ATTENDEE_STATUS_ACCEPTED,
                Attendees.ATTENDEE_STATUS_TENTATIVE -> p.setStyle(
                Style.FILL_AND_STROKE
            )
            else -> p.setStyle(Style.FILL_AND_STROKE)
        }
        p.setAntiAlias(false)
        val floorHalfStroke = Math.floor(EVENT_RECT_STROKE_WIDTH.toDouble() / 2.0).toInt()
        val ceilHalfStroke = Math.ceil(EVENT_RECT_STROKE_WIDTH.toDouble() / 2.0).toInt()
        r.top = Math.max(event.top.toInt() + EVENT_RECT_TOP_MARGIN + floorHalfStroke, visibleTop)
        r.bottom = Math.min(
            event.bottom.toInt() - EVENT_RECT_BOTTOM_MARGIN - ceilHalfStroke,
            visibleBot
        )
        r.left += floorHalfStroke
        r.right -= ceilHalfStroke
        p.setStrokeWidth(EVENT_RECT_STROKE_WIDTH.toFloat())
        p.setColor(color)
        val alpha: Int = p.getAlpha()
        p.setAlpha(mEventsAlpha)
        canvas.drawRect(r, p)
        p.setAlpha(alpha)
        p.setStyle(Style.FILL)

        // Setup rect for drawEventText which follows
        r.top = event.top.toInt() + EVENT_RECT_TOP_MARGIN
        r.bottom = event.bottom.toInt() - EVENT_RECT_BOTTOM_MARGIN
        r.left = event.left.toInt() + EVENT_RECT_LEFT_MARGIN
        r.right = event.right.toInt() - EVENT_RECT_RIGHT_MARGIN
        return r
    }

    private val drawTextSanitizerFilter: Pattern = Pattern.compile("[\t\n],")

    // Sanitize a string before passing it to drawText or else we get little
    // squares. For newlines and tabs before a comma, delete the character.
    // Otherwise, just replace them with a space.
    private fun drawTextSanitizer(string: String, maxEventTextLen: Int): String {
        var string = string
        val m: Matcher = drawTextSanitizerFilter.matcher(string)
        string = m.replaceAll(",")
        var len: Int = string.length
        if (maxEventTextLen <= 0) {
            string = ""
            len = 0
        } else if (len > maxEventTextLen) {
            string = string.substring(0, maxEventTextLen)
            len = maxEventTextLen
        }
        return string.replace('\n', ' ')
    }

    private fun drawEventText(
        eventLayout: StaticLayout?,
        rect: Rect,
        canvas: Canvas,
        top: Int,
        bottom: Int,
        center: Boolean
    ) {
        // drawEmptyRect(canvas, rect, 0xFFFF00FF); // for debugging
        val width: Int = rect.right - rect.left
        val height: Int = rect.bottom - rect.top

        // If the rectangle is too small for text, then return
        if (eventLayout == null || width < MIN_CELL_WIDTH_FOR_TEXT) {
            return
        }
        var totalLineHeight = 0
        val lineCount: Int = eventLayout.getLineCount()
        for (i in 0 until lineCount) {
            val lineBottom: Int = eventLayout.getLineBottom(i)
            totalLineHeight = if (lineBottom <= height) {
                lineBottom
            } else {
                break
            }
        }

        // + 2 is small workaround when the font is slightly bigger than the rect. This will
        // still allow the text to be shown without overflowing into the other all day rects.
        if (totalLineHeight == 0 || rect.top > bottom || rect.top + totalLineHeight + 2 < top) {
            return
        }

        // Use a StaticLayout to format the string.
        canvas.save()
        //  canvas.translate(rect.left, rect.top + (rect.bottom - rect.top / 2));
        val padding = if (center) (rect.bottom - rect.top - totalLineHeight) / 2 else 0
        canvas.translate(rect.left.toFloat(), rect.top.toFloat() + padding)
        rect.left = 0
        rect.right = width
        rect.top = 0
        rect.bottom = totalLineHeight

        // There's a bug somewhere. If this rect is outside of a previous
        // cliprect, this becomes a no-op. What happens is that the text draw
        // past the event rect. The current fix is to not draw the staticLayout
        // at all if it is completely out of bound.
        canvas.clipRect(rect)
        eventLayout.draw(canvas)
        canvas.restore()
    }

    // The following routines are called from the parent activity when certain
    // touch events occur.
    private fun doDown(ev: MotionEvent) {
        mTouchMode = TOUCH_MODE_DOWN
        mViewStartX = 0
        mOnFlingCalled = false
        mHandler?.removeCallbacks(mContinueScroll)
        val x = ev.getX().toInt()
        val y = ev.getY().toInt()

        // Save selection information: we use setSelectionFromPosition to find the selected event
        // in order to show the "clicked" color. But since it is also setting the selected info
        // for new events, we need to restore the old info after calling the function.
        val oldSelectedEvent: Event? = mSelectedEvent
        val oldSelectionDay = mSelectionDay
        val oldSelectionHour = mSelectionHour
        if (setSelectionFromPosition(x, y, false)) {
            // If a time was selected (a blue selection box is visible) and the click location
            // is in the selected time, do not show a click on an event to prevent a situation
            // of both a selection and an event are clicked when they overlap.
            val pressedSelected = (mSelectionMode != SELECTION_HIDDEN &&
                oldSelectionDay == mSelectionDay && oldSelectionHour == mSelectionHour)
            if (!pressedSelected && mSelectedEvent != null) {
                mSavedClickedEvent = mSelectedEvent
                mDownTouchTime = System.currentTimeMillis()
                postDelayed(mSetClick, mOnDownDelay.toLong())
            } else {
                eventClickCleanup()
            }
        }
        mSelectedEvent = oldSelectedEvent
        mSelectionDay = oldSelectionDay
        mSelectionHour = oldSelectionHour
        invalidate()
    }

    // Kicks off all the animations when the expand allday area is tapped
    private fun doExpandAllDayClick() {
        mShowAllAllDayEvents = !mShowAllAllDayEvents
        ObjectAnimator.setFrameDelay(0)

        // Determine the starting height
        if (mAnimateDayHeight == 0) {
            mAnimateDayHeight =
                if (mShowAllAllDayEvents) mAlldayHeight - MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT.toInt()
                else mAlldayHeight
        }
        // Cancel current animations
        mCancellingAnimations = true
        if (mAlldayAnimator != null) {
            mAlldayAnimator?.cancel()
        }
        if (mAlldayEventAnimator != null) {
            mAlldayEventAnimator?.cancel()
        }
        if (mMoreAlldayEventsAnimator != null) {
            mMoreAlldayEventsAnimator?.cancel()
        }
        mCancellingAnimations = false
        // get new animators
        mAlldayAnimator = allDayAnimator
        mAlldayEventAnimator = allDayEventAnimator
        mMoreAlldayEventsAnimator = ObjectAnimator.ofInt(
            this,
            "moreAllDayEventsTextAlpha",
            if (mShowAllAllDayEvents) MORE_EVENTS_MAX_ALPHA else 0,
            if (mShowAllAllDayEvents) 0 else MORE_EVENTS_MAX_ALPHA
        )

        // Set up delays and start the animators
        mAlldayAnimator?.setStartDelay(if (mShowAllAllDayEvents) ANIMATION_SECONDARY_DURATION
            else 0)
        mAlldayAnimator?.start()
        mMoreAlldayEventsAnimator?.setStartDelay(if (mShowAllAllDayEvents) 0
            else ANIMATION_DURATION)
        mMoreAlldayEventsAnimator?.setDuration(ANIMATION_SECONDARY_DURATION)
        mMoreAlldayEventsAnimator?.start()
        if (mAlldayEventAnimator != null) {
            // This is the only animator that can return null, so check it
            mAlldayEventAnimator
                ?.setStartDelay(if (mShowAllAllDayEvents) ANIMATION_SECONDARY_DURATION else 0)
            mAlldayEventAnimator?.start()
        }
    }

    /**
     * Figures out the initial heights for allDay events and space when
     * a view is being set up.
     */
    fun initAllDayHeights() {
        if (mMaxAlldayEvents <= mMaxUnexpandedAlldayEventCount) {
            return
        }
        if (mShowAllAllDayEvents) {
            var maxADHeight = mViewHeight - DAY_HEADER_HEIGHT - MIN_HOURS_HEIGHT
            maxADHeight = Math.min(
                maxADHeight,
                (mMaxAlldayEvents * MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT).toInt()
            )
            mAnimateDayEventHeight = maxADHeight / mMaxAlldayEvents
        } else {
            mAnimateDayEventHeight = MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT.toInt()
        }
    } // First calculate the absolute max height
    // Now expand to fit but not beyond the absolute max
    // calculate the height of individual events in order to fit
    // if there's nothing to animate just return

    // Set up the animator with the calculated values
    // Sets up an animator for changing the height of allday events
    private val allDayEventAnimator: ObjectAnimator?
        private get() {
            // First calculate the absolute max height
            var maxADHeight = mViewHeight - DAY_HEADER_HEIGHT - MIN_HOURS_HEIGHT
            // Now expand to fit but not beyond the absolute max
            maxADHeight = Math.min(
                maxADHeight,
                (mMaxAlldayEvents * MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT).toInt()
            )
            // calculate the height of individual events in order to fit
            val fitHeight = maxADHeight / mMaxAlldayEvents
            val currentHeight = mAnimateDayEventHeight
            val desiredHeight =
                if (mShowAllAllDayEvents) fitHeight else MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT.toInt()
            // if there's nothing to animate just return
            if (currentHeight == desiredHeight) {
                return null
            }

            // Set up the animator with the calculated values
            val animator: ObjectAnimator = ObjectAnimator.ofInt(
                this, "animateDayEventHeight",
                currentHeight, desiredHeight
            )
            animator.setDuration(ANIMATION_DURATION)
            return animator
        }

    // Set up the animator with the calculated values
    // Sets up an animator for changing the height of the allday area
    private val allDayAnimator: ObjectAnimator
        private get() {
            // Calculate the absolute max height
            var maxADHeight = mViewHeight - DAY_HEADER_HEIGHT - MIN_HOURS_HEIGHT
            // Find the desired height but don't exceed abs max
            maxADHeight = Math.min(
                maxADHeight,
                (mMaxAlldayEvents * MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT).toInt()
            )
            // calculate the current and desired heights
            val currentHeight = if (mAnimateDayHeight != 0) mAnimateDayHeight else mAlldayHeight
            val desiredHeight =
                if (mShowAllAllDayEvents) maxADHeight else (MAX_UNEXPANDED_ALLDAY_HEIGHT -
                    MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT - 1).toInt()

            // Set up the animator with the calculated values
            val animator: ObjectAnimator = ObjectAnimator.ofInt(
                this, "animateDayHeight",
                currentHeight, desiredHeight
            )
            animator.setDuration(ANIMATION_DURATION)
            animator.addListener(object : AnimatorListenerAdapter() {
                @Override
                override fun onAnimationEnd(animation: Animator) {
                    if (!mCancellingAnimations) {
                        // when finished, set this to 0 to signify not animating
                        mAnimateDayHeight = 0
                        mUseExpandIcon = !mShowAllAllDayEvents
                    }
                    mRemeasure = true
                    invalidate()
                }
            })
            return animator
        }

    // setter for the 'box +n' alpha text used by the animator
    fun setMoreAllDayEventsTextAlpha(alpha: Int) {
        mMoreAlldayEventsTextAlpha = alpha
        invalidate()
    }

    // setter for the height of the allday area used by the animator
    fun setAnimateDayHeight(height: Int) {
        mAnimateDayHeight = height
        mRemeasure = true
        invalidate()
    }

    // setter for the height of allday events used by the animator
    fun setAnimateDayEventHeight(height: Int) {
        mAnimateDayEventHeight = height
        mRemeasure = true
        invalidate()
    }

    private fun doSingleTapUp(ev: MotionEvent) {
        if (!mHandleActionUp || mScrolling) {
            return
        }
        val x = ev.getX().toInt()
        val y = ev.getY().toInt()
        val selectedDay = mSelectionDay
        val selectedHour = mSelectionHour
        if (mMaxAlldayEvents > mMaxUnexpandedAlldayEventCount) {
            // check if the tap was in the allday expansion area
            val bottom = mFirstCell
            if (x < mHoursWidth && y > DAY_HEADER_HEIGHT && y < DAY_HEADER_HEIGHT + mAlldayHeight ||
                !mShowAllAllDayEvents && mAnimateDayHeight == 0 && y < bottom && y >= bottom -
                MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT
            ) {
                doExpandAllDayClick()
                return
            }
        }
        val validPosition = setSelectionFromPosition(x, y, false)
        if (!validPosition) {
            if (y < DAY_HEADER_HEIGHT) {
                val selectedTime = Time(mBaseDate)
                selectedTime.setJulianDay(mSelectionDay)
                selectedTime.hour = mSelectionHour
                selectedTime.normalize(true /* ignore isDst */)
                mController.sendEvent(
                    this as? Object, EventType.GO_TO, null, null, selectedTime, -1,
                    ViewType.DAY, CalendarController.EXTRA_GOTO_DATE, null, null
                )
            }
            return
        }
        val hasSelection = mSelectionMode != SELECTION_HIDDEN
        val pressedSelected = ((hasSelection || mTouchExplorationEnabled) &&
            selectedDay == mSelectionDay && selectedHour == mSelectionHour)
        if (mSelectedEvent != null) {
            // If the tap is on an event, launch the "View event" view
            if (mIsAccessibilityEnabled) {
                mAccessibilityMgr?.interrupt()
            }
            mSelectionMode = SELECTION_HIDDEN
            var yLocation = ((mSelectedEvent!!.top + mSelectedEvent!!.bottom) / 2) as Int
            // Y location is affected by the position of the event in the scrolling
            // view (mViewStartY) and the presence of all day events (mFirstCell)
            if (!mSelectedEvent!!.allDay) {
                yLocation += mFirstCell - mViewStartY
            }
            mClickedYLocation = yLocation
            val clearDelay: Long = CLICK_DISPLAY_DURATION + mOnDownDelay -
                (System.currentTimeMillis() - mDownTouchTime)
            if (clearDelay > 0) {
                this.postDelayed(mClearClick, clearDelay)
            } else {
                this.post(mClearClick)
            }
        }
        invalidate()
    }

    private fun doLongPress(ev: MotionEvent) {
        eventClickCleanup()
        if (mScrolling) {
            return
        }

        // Scale gesture in progress
        if (mStartingSpanY != 0f) {
            return
        }
        val x = ev.getX().toInt()
        val y = ev.getY().toInt()
        val validPosition = setSelectionFromPosition(x, y, false)
        if (!validPosition) {
            // return if the touch wasn't on an area of concern
            return
        }
        invalidate()
        performLongClick()
    }

    private fun doScroll(e1: MotionEvent?, e2: MotionEvent, deltaX: Float, deltaY: Float) {
        cancelAnimation()
        if (mStartingScroll) {
            mInitialScrollX = 0f
            mInitialScrollY = 0f
            mStartingScroll = false
        }
        mInitialScrollX += deltaX
        mInitialScrollY += deltaY
        val distanceX = mInitialScrollX.toInt()
        val distanceY = mInitialScrollY.toInt()
        val focusY = getAverageY(e2)
        if (mRecalCenterHour) {
            // Calculate the hour that correspond to the average of the Y touch points
            mGestureCenterHour = ((mViewStartY + focusY - DAY_HEADER_HEIGHT - mAlldayHeight) /
                (mCellHeight + DAY_GAP))
            mRecalCenterHour = false
        }

        // If we haven't figured out the predominant scroll direction yet,
        // then do it now.
        if (mTouchMode == TOUCH_MODE_DOWN) {
            val absDistanceX: Int = Math.abs(distanceX)
            val absDistanceY: Int = Math.abs(distanceY)
            mScrollStartY = mViewStartY
            mPreviousDirection = 0
            if (absDistanceX > absDistanceY) {
                val slopFactor = if (mScaleGestureDetector.isInProgress()) 20 else 2
                if (absDistanceX > mScaledPagingTouchSlop * slopFactor) {
                    mTouchMode = TOUCH_MODE_HSCROLL
                    mViewStartX = distanceX
                    initNextView(-mViewStartX)
                }
            } else {
                mTouchMode = TOUCH_MODE_VSCROLL
            }
        } else if (mTouchMode and TOUCH_MODE_HSCROLL != 0) {
            // We are already scrolling horizontally, so check if we
            // changed the direction of scrolling so that the other week
            // is now visible.
            mViewStartX = distanceX
            if (distanceX != 0) {
                val direction = if (distanceX > 0) 1 else -1
                if (direction != mPreviousDirection) {
                    // The user has switched the direction of scrolling
                    // so re-init the next view
                    initNextView(-mViewStartX)
                    mPreviousDirection = direction
                }
            }
        }
        if (mTouchMode and TOUCH_MODE_VSCROLL != 0) {
            // Calculate the top of the visible region in the calendar grid.
            // Increasing/decrease this will scroll the calendar grid up/down.
            mViewStartY = ((mGestureCenterHour * (mCellHeight + DAY_GAP) -
                focusY) + DAY_HEADER_HEIGHT + mAlldayHeight).toInt()

            // If dragging while already at the end, do a glow
            val pulledToY = (mScrollStartY + deltaY).toInt()
            if (pulledToY < 0) {
                mEdgeEffectTop.onPull(deltaY / mViewHeight)
                if (!mEdgeEffectBottom.isFinished()) {
                    mEdgeEffectBottom.onRelease()
                }
            } else if (pulledToY > mMaxViewStartY) {
                mEdgeEffectBottom.onPull(deltaY / mViewHeight)
                if (!mEdgeEffectTop.isFinished()) {
                    mEdgeEffectTop.onRelease()
                }
            }
            if (mViewStartY < 0) {
                mViewStartY = 0
                mRecalCenterHour = true
            } else if (mViewStartY > mMaxViewStartY) {
                mViewStartY = mMaxViewStartY
                mRecalCenterHour = true
            }
            if (mRecalCenterHour) {
                // Calculate the hour that correspond to the average of the Y touch points
                mGestureCenterHour = ((mViewStartY + focusY - DAY_HEADER_HEIGHT - mAlldayHeight) /
                    (mCellHeight + DAY_GAP))
                mRecalCenterHour = false
            }
            computeFirstHour()
        }
        mScrolling = true
        mSelectionMode = SELECTION_HIDDEN
        invalidate()
    }

    private fun getAverageY(me: MotionEvent): Float {
        val count: Int = me.getPointerCount()
        var focusY = 0f
        for (i in 0 until count) {
            focusY += me.getY(i)
        }
        focusY /= count.toFloat()
        return focusY
    }

    private fun cancelAnimation() {
        val `in`: Animation? = mViewSwitcher.getInAnimation()
        if (`in` != null) {
            // cancel() doesn't terminate cleanly.
            `in`.scaleCurrentDuration(0f)
        }
        val out: Animation? = mViewSwitcher.getOutAnimation()
        if (out != null) {
            // cancel() doesn't terminate cleanly.
            out.scaleCurrentDuration(0f)
        }
    }

    private fun doFling(e1: MotionEvent?, e2: MotionEvent, velocityX: Float, velocityY: Float) {
        cancelAnimation()
        mSelectionMode = SELECTION_HIDDEN
        eventClickCleanup()
        mOnFlingCalled = true
        if (mTouchMode and TOUCH_MODE_HSCROLL != 0) {
            // Horizontal fling.
            // initNextView(deltaX);
            mTouchMode = TOUCH_MODE_INITIAL_STATE
            if (DEBUG) Log.d(TAG, "doFling: velocityX $velocityX")
            val deltaX = e2.getX().toInt() - e1!!.getX().toInt()
            switchViews(deltaX < 0, mViewStartX.toFloat(), mViewWidth.toFloat(), velocityX)
            mViewStartX = 0
            return
        }
        if (mTouchMode and TOUCH_MODE_VSCROLL == 0) {
            if (DEBUG) Log.d(TAG, "doFling: no fling")
            return
        }

        // Vertical fling.
        mTouchMode = TOUCH_MODE_INITIAL_STATE
        mViewStartX = 0
        if (DEBUG) {
            Log.d(TAG, "doFling: mViewStartY$mViewStartY velocityY $velocityY")
        }

        // Continue scrolling vertically
        mScrolling = true
        mScroller.fling(
            0 /* startX */, mViewStartY /* startY */, 0 /* velocityX */,
            (-velocityY).toInt(), 0 /* minX */, 0 /* maxX */, 0 /* minY */,
            mMaxViewStartY /* maxY */, OVERFLING_DISTANCE, OVERFLING_DISTANCE
        )

        // When flinging down, show a glow when it hits the end only if it
        // wasn't started at the top
        if (velocityY > 0 && mViewStartY != 0) {
            mCallEdgeEffectOnAbsorb = true
        } else if (velocityY < 0 && mViewStartY != mMaxViewStartY) {
            mCallEdgeEffectOnAbsorb = true
        }
        mHandler?.post(mContinueScroll)
    }

    private fun initNextView(deltaX: Int): Boolean {
        // Change the view to the previous day or week
        val view = mViewSwitcher.getNextView() as DayView
        val date: Time? = view.mBaseDate
        date?.set(mBaseDate)
        val switchForward: Boolean
        if (deltaX > 0) {
            date!!.monthDay -= mNumDays
            view.setSelectedDay(mSelectionDay - mNumDays)
            switchForward = false
        } else {
            date!!.monthDay += mNumDays
            view.setSelectedDay(mSelectionDay + mNumDays)
            switchForward = true
        }
        date?.normalize(true /* ignore isDst */)
        initView(view)
        view.layout(getLeft(), getTop(), getRight(), getBottom())
        view.reloadEvents()
        return switchForward
    }

    // ScaleGestureDetector.OnScaleGestureListener
    override fun onScaleBegin(detector: ScaleGestureDetector): Boolean {
        mHandleActionUp = false
        val gestureCenterInPixels: Float = detector.getFocusY() - DAY_HEADER_HEIGHT - mAlldayHeight
        mGestureCenterHour = (mViewStartY + gestureCenterInPixels) / (mCellHeight + DAY_GAP)
        mStartingSpanY = Math.max(MIN_Y_SPAN.toFloat(),
            Math.abs(detector.getCurrentSpanY().toFloat()))
        mCellHeightBeforeScaleGesture = mCellHeight
        if (DEBUG_SCALING) {
            val ViewStartHour = mViewStartY / (mCellHeight + DAY_GAP).toFloat()
            Log.d(
                TAG, "onScaleBegin: mGestureCenterHour:" + mGestureCenterHour +
                    "\tViewStartHour: " + ViewStartHour + "\tmViewStartY:" + mViewStartY +
                    "\tmCellHeight:" + mCellHeight + " SpanY:" + detector.getCurrentSpanY()
            )
        }
        return true
    }

    // ScaleGestureDetector.OnScaleGestureListener
    override fun onScale(detector: ScaleGestureDetector): Boolean {
        val spanY: Float = Math.max(MIN_Y_SPAN.toFloat(),
            Math.abs(detector.getCurrentSpanY().toFloat()))
        mCellHeight = (mCellHeightBeforeScaleGesture * spanY / mStartingSpanY).toInt()
        if (mCellHeight < mMinCellHeight) {
            // If mStartingSpanY is too small, even a small increase in the
            // gesture can bump the mCellHeight beyond MAX_CELL_HEIGHT
            mStartingSpanY = spanY
            mCellHeight = mMinCellHeight
            mCellHeightBeforeScaleGesture = mMinCellHeight
        } else if (mCellHeight > MAX_CELL_HEIGHT) {
            mStartingSpanY = spanY
            mCellHeight = MAX_CELL_HEIGHT
            mCellHeightBeforeScaleGesture = MAX_CELL_HEIGHT
        }
        val gestureCenterInPixels = detector.getFocusY().toInt() - DAY_HEADER_HEIGHT - mAlldayHeight
        mViewStartY = (mGestureCenterHour * (mCellHeight + DAY_GAP)).toInt() - gestureCenterInPixels
        mMaxViewStartY = HOUR_GAP + 24 * (mCellHeight + HOUR_GAP) - mGridAreaHeight
        if (DEBUG_SCALING) {
            val ViewStartHour = mViewStartY / (mCellHeight + DAY_GAP).toFloat()
            Log.d(
                TAG, "onScale: mGestureCenterHour:" + mGestureCenterHour + "\tViewStartHour: " +
                    ViewStartHour + "\tmViewStartY:" + mViewStartY + "\tmCellHeight:" +
                    mCellHeight + " SpanY:" + detector.getCurrentSpanY()
            )
        }
        if (mViewStartY < 0) {
            mViewStartY = 0
            mGestureCenterHour = ((mViewStartY + gestureCenterInPixels) /
                (mCellHeight + DAY_GAP).toFloat())
        } else if (mViewStartY > mMaxViewStartY) {
            mViewStartY = mMaxViewStartY
            mGestureCenterHour = ((mViewStartY + gestureCenterInPixels) /
                (mCellHeight + DAY_GAP).toFloat())
        }
        computeFirstHour()
        mRemeasure = true
        invalidate()
        return true
    }

    // ScaleGestureDetector.OnScaleGestureListener
    override fun onScaleEnd(detector: ScaleGestureDetector) {
        mScrollStartY = mViewStartY
        mInitialScrollY = 0f
        mInitialScrollX = 0f
        mStartingSpanY = 0f
    }

    @Override
    override fun onTouchEvent(ev: MotionEvent): Boolean {
        val action: Int = ev.getAction()
        if (DEBUG) Log.e(TAG, "" + action + " ev.getPointerCount() = " + ev.getPointerCount())
        if (ev.getActionMasked() === MotionEvent.ACTION_DOWN ||
            ev.getActionMasked() === MotionEvent.ACTION_UP ||
            ev.getActionMasked() === MotionEvent.ACTION_POINTER_UP ||
            ev.getActionMasked() === MotionEvent.ACTION_POINTER_DOWN
        ) {
            mRecalCenterHour = true
        }
        if (mTouchMode and TOUCH_MODE_HSCROLL == 0) {
            mScaleGestureDetector.onTouchEvent(ev)
        }
        return when (action) {
            MotionEvent.ACTION_DOWN -> {
                mStartingScroll = true
                if (DEBUG) {
                    Log.e(
                        TAG,
                        "ACTION_DOWN ev.getDownTime = " + ev.getDownTime().toString() + " Cnt=" +
                            ev.getPointerCount()
                    )
                }
                val bottom =
                    mAlldayHeight + DAY_HEADER_HEIGHT + ALLDAY_TOP_MARGIN
                mTouchStartedInAlldayArea = if (ev.getY() < bottom) {
                    true
                } else {
                    false
                }
                mHandleActionUp = true
                mGestureDetector.onTouchEvent(ev)
                true
            }
            MotionEvent.ACTION_MOVE -> {
                if (DEBUG) Log.e(
                    TAG,
                    "ACTION_MOVE Cnt=" + ev.getPointerCount() + this@DayView
                )
                mGestureDetector.onTouchEvent(ev)
                true
            }
            MotionEvent.ACTION_UP -> {
                if (DEBUG) Log.e(
                    TAG,
                    "ACTION_UP Cnt=" + ev.getPointerCount() + mHandleActionUp
                )
                mEdgeEffectTop.onRelease()
                mEdgeEffectBottom.onRelease()
                mStartingScroll = false
                mGestureDetector.onTouchEvent(ev)
                if (!mHandleActionUp) {
                    mHandleActionUp = true
                    mViewStartX = 0
                    invalidate()
                    return true
                }
                if (mOnFlingCalled) {
                    return true
                }

                // If we were scrolling, then reset the selected hour so that it
                // is visible.
                if (mScrolling) {
                    mScrolling = false
                    resetSelectedHour()
                    invalidate()
                }
                if (mTouchMode and TOUCH_MODE_HSCROLL != 0) {
                    mTouchMode = TOUCH_MODE_INITIAL_STATE
                    if (Math.abs(mViewStartX) > mHorizontalSnapBackThreshold) {
                        // The user has gone beyond the threshold so switch views
                        if (DEBUG) Log.d(
                            TAG,
                            "- horizontal scroll: switch views"
                        )
                        switchViews(
                            mViewStartX > 0,
                            mViewStartX.toFloat(),
                            mViewWidth.toFloat(),
                            0f
                        )
                        mViewStartX = 0
                        return true
                    } else {
                        // Not beyond the threshold so invalidate which will cause
                        // the view to snap back. Also call recalc() to ensure
                        // that we have the correct starting date and title.
                        if (DEBUG) Log.d(
                            TAG,
                            "- horizontal scroll: snap back"
                        )
                        recalc()
                        invalidate()
                        mViewStartX = 0
                    }
                }
                true
            }
            MotionEvent.ACTION_CANCEL -> {
                if (DEBUG) Log.e(
                    TAG,
                    "ACTION_CANCEL"
                )
                mGestureDetector.onTouchEvent(ev)
                mScrolling = false
                resetSelectedHour()
                true
            }
            else -> {
                if (DEBUG) Log.e(
                    TAG,
                    "Not MotionEvent " + ev.toString()
                )
                if (mGestureDetector.onTouchEvent(ev)) {
                    true
                } else super.onTouchEvent(ev)
            }
        }
    }

    override fun onCreateContextMenu(menu: ContextMenu, view: View?, menuInfo: ContextMenuInfo?) {
        var item: MenuItem

        // If the trackball is held down, then the context menu pops up and
        // we never get onKeyUp() for the long-press. So check for it here
        // and change the selection to the long-press state.
        if (mSelectionMode != SELECTION_LONGPRESS) {
            invalidate()
        }
        val startMillis = selectedTimeInMillis
        val flags: Int = (DateUtils.FORMAT_SHOW_TIME
            or DateUtils.FORMAT_CAP_NOON_MIDNIGHT
            or DateUtils.FORMAT_SHOW_WEEKDAY)
        val title: String? = Utils.formatDateRange(mContext, startMillis, startMillis, flags)
        menu.setHeaderTitle(title)
        mPopup?.dismiss()
    }

    /**
     * Sets mSelectionDay and mSelectionHour based on the (x,y) touch position.
     * If the touch position is not within the displayed grid, then this
     * method returns false.
     *
     * @param x the x position of the touch
     * @param y the y position of the touch
     * @param keepOldSelection - do not change the selection info (used for invoking accessibility
     * messages)
     * @return true if the touch position is valid
     */
    private fun setSelectionFromPosition(x: Int, y: Int, keepOldSelection: Boolean): Boolean {
        var x = x
        var savedEvent: Event? = null
        var savedDay = 0
        var savedHour = 0
        var savedAllDay = false
        if (keepOldSelection) {
            // Store selection info and restore it at the end. This way, we can invoke the
            // right accessibility message without affecting the selection.
            savedEvent = mSelectedEvent
            savedDay = mSelectionDay
            savedHour = mSelectionHour
            savedAllDay = mSelectionAllday
        }
        if (x < mHoursWidth) {
            x = mHoursWidth
        }
        var day = (x - mHoursWidth) / (mCellWidth + DAY_GAP)
        if (day >= mNumDays) {
            day = mNumDays - 1
        }
        day += mFirstJulianDay
        setSelectedDay(day)
        if (y < DAY_HEADER_HEIGHT) {
            sendAccessibilityEventAsNeeded(false)
            return false
        }
        setSelectedHour(mFirstHour) /* First fully visible hour */
        mSelectionAllday = if (y < mFirstCell) {
            true
        } else {
            // y is now offset from top of the scrollable region
            val adjustedY = y - mFirstCell
            if (adjustedY < mFirstHourOffset) {
                setSelectedHour(mSelectionHour - 1) /* In the partially visible hour */
            } else {
                setSelectedHour(
                    mSelectionHour +
                        (adjustedY - mFirstHourOffset) / (mCellHeight + HOUR_GAP)
                )
            }
            false
        }
        findSelectedEvent(x, y)
        sendAccessibilityEventAsNeeded(true)

        // Restore old values
        if (keepOldSelection) {
            mSelectedEvent = savedEvent
            mSelectionDay = savedDay
            mSelectionHour = savedHour
            mSelectionAllday = savedAllDay
        }
        return true
    }

    private fun findSelectedEvent(x: Int, y: Int) {
        var y = y
        val date = mSelectionDay
        val cellWidth = mCellWidth
        var events: ArrayList<Event>? = mEvents
        var numEvents: Int = events!!.size
        val left = computeDayLeftPosition(mSelectionDay - mFirstJulianDay)
        val top = 0
        setSelectedEvent(null)
        mSelectedEvents.clear()
        if (mSelectionAllday) {
            var yDistance: Float
            var minYdistance = 10000.0f // any large number
            var closestEvent: Event? = null
            val drawHeight = mAlldayHeight.toFloat()
            val yOffset = DAY_HEADER_HEIGHT + ALLDAY_TOP_MARGIN
            var maxUnexpandedColumn = mMaxUnexpandedAlldayEventCount
            if (mMaxAlldayEvents > mMaxUnexpandedAlldayEventCount) {
                // Leave a gap for the 'box +n' text
                maxUnexpandedColumn--
            }
            events = mAllDayEvents
            numEvents = events!!.size
            for (i in 0 until numEvents) {
                val event: Event? = events.get(i)
                if (!event!!.drawAsAllday() ||
                    !mShowAllAllDayEvents && event.getColumn() >= maxUnexpandedColumn
                ) {
                    // Don't check non-allday events or events that aren't shown
                    continue
                }
                if (event.startDay <= mSelectionDay && event.endDay >= mSelectionDay) {
                    val numRectangles =
                        if (mShowAllAllDayEvents) mMaxAlldayEvents.toFloat()
                        else mMaxUnexpandedAlldayEventCount.toFloat()
                    var height = drawHeight / numRectangles
                    if (height > MAX_HEIGHT_OF_ONE_ALLDAY_EVENT) {
                        height = MAX_HEIGHT_OF_ONE_ALLDAY_EVENT.toFloat()
                    }
                    val eventTop: Float = yOffset + height * event.getColumn()
                    val eventBottom = eventTop + height
                    if (eventTop < y && eventBottom > y) {
                        // If the touch is inside the event rectangle, then
                        // add the event.
                        mSelectedEvents.add(event)
                        closestEvent = event
                        break
                    } else {
                        // Find the closest event
                        yDistance = if (eventTop >= y) {
                            eventTop - y
                        } else {
                            y - eventBottom
                        }
                        if (yDistance < minYdistance) {
                            minYdistance = yDistance
                            closestEvent = event
                        }
                    }
                }
            }
            setSelectedEvent(closestEvent)
            return
        }

        // Adjust y for the scrollable bitmap
        y += mViewStartY - mFirstCell

        // Use a region around (x,y) for the selection region
        val region: Rect = mRect
        region.left = x - 10
        region.right = x + 10
        region.top = y - 10
        region.bottom = y + 10
        val geometry: EventGeometry = mEventGeometry
        for (i in 0 until numEvents) {
            val event: Event? = events.get(i)
            // Compute the event rectangle.
            if (!geometry.computeEventRect(date, left, top, cellWidth, event as Event)) {
                continue
            }

            // If the event intersects the selection region, then add it to
            // mSelectedEvents.
            if (geometry.eventIntersectsSelection(event as Event, region)) {
                mSelectedEvents.add(event as Event)
            }
        }

        // If there are any events in the selected region, then assign the
        // closest one to mSelectedEvent.
        if (mSelectedEvents.size > 0) {
            val len: Int = mSelectedEvents.size
            var closestEvent: Event? = null
            var minDist = (mViewWidth + mViewHeight).toFloat() // some large distance
            for (index in 0 until len) {
                val ev: Event? = mSelectedEvents.get(index)
                val dist: Float = geometry.pointToEvent(x.toFloat(), y.toFloat(), ev as Event)
                if (dist < minDist) {
                    minDist = dist
                    closestEvent = ev
                }
            }
            setSelectedEvent(closestEvent)

            // Keep the selected hour and day consistent with the selected
            // event. They could be different if we touched on an empty hour
            // slot very close to an event in the previous hour slot. In
            // that case we will select the nearby event.
            val startDay: Int = mSelectedEvent!!.startDay
            val endDay: Int = mSelectedEvent!!.endDay
            if (mSelectionDay < startDay) {
                setSelectedDay(startDay)
            } else if (mSelectionDay > endDay) {
                setSelectedDay(endDay)
            }
            val startHour: Int = mSelectedEvent!!.startTime / 60
            val endHour: Int
            endHour = if (mSelectedEvent!!.startTime < mSelectedEvent!!.endTime) {
                (mSelectedEvent!!.endTime - 1) / 60
            } else {
                mSelectedEvent!!.endTime / 60
            }
            if (mSelectionHour < startHour && mSelectionDay == startDay) {
                setSelectedHour(startHour)
            } else if (mSelectionHour > endHour && mSelectionDay == endDay) {
                setSelectedHour(endHour)
            }
        }
    }

    // Encapsulates the code to continue the scrolling after the
    // finger is lifted. Instead of stopping the scroll immediately,
    // the scroll continues to "free spin" and gradually slows down.
    private inner class ContinueScroll : Runnable {
        override fun run() {
            mScrolling = mScrolling && mScroller.computeScrollOffset()
            if (!mScrolling || mPaused) {
                resetSelectedHour()
                invalidate()
                return
            }
            mViewStartY = mScroller.getCurrY()
            if (mCallEdgeEffectOnAbsorb) {
                if (mViewStartY < 0) {
                    mEdgeEffectTop.onAbsorb(mLastVelocity.toInt())
                    mCallEdgeEffectOnAbsorb = false
                } else if (mViewStartY > mMaxViewStartY) {
                    mEdgeEffectBottom.onAbsorb(mLastVelocity.toInt())
                    mCallEdgeEffectOnAbsorb = false
                }
                mLastVelocity = mScroller.getCurrVelocity()
            }
            if (mScrollStartY == 0 || mScrollStartY == mMaxViewStartY) {
                // Allow overscroll/springback only on a fling,
                // not a pull/fling from the end
                if (mViewStartY < 0) {
                    mViewStartY = 0
                } else if (mViewStartY > mMaxViewStartY) {
                    mViewStartY = mMaxViewStartY
                }
            }
            computeFirstHour()
            mHandler?.post(this)
            invalidate()
        }
    }

    /**
     * Cleanup the pop-up and timers.
     */
    fun cleanup() {
        // Protect against null-pointer exceptions
        if (mPopup != null) {
            mPopup?.dismiss()
        }
        mPaused = true
        mLastPopupEventID = INVALID_EVENT_ID
        if (mHandler != null) {
            mHandler?.removeCallbacks(mDismissPopup)
            mHandler?.removeCallbacks(mUpdateCurrentTime)
        }
        Utils.setSharedPreference(
            mContext, GeneralPreferences.KEY_DEFAULT_CELL_HEIGHT,
            mCellHeight
        )
        // Clear all click animations
        eventClickCleanup()
        // Turn off redraw
        mRemeasure = false
        // Turn off scrolling to make sure the view is in the correct state if we fling back to it
        mScrolling = false
    }

    private fun eventClickCleanup() {
        this.removeCallbacks(mClearClick)
        this.removeCallbacks(mSetClick)
        mClickedEvent = null
        mSavedClickedEvent = null
    }

    private fun setSelectedEvent(e: Event?) {
        mSelectedEvent = e
        mSelectedEventForAccessibility = e
    }

    private fun setSelectedHour(h: Int) {
        mSelectionHour = h
        mSelectionHourForAccessibility = h
    }

    private fun setSelectedDay(d: Int) {
        mSelectionDay = d
        mSelectionDayForAccessibility = d
    }

    /**
     * Restart the update timer
     */
    fun restartCurrentTimeUpdates() {
        mPaused = false
        if (mHandler != null) {
            mHandler?.removeCallbacks(mUpdateCurrentTime)
            mHandler?.post(mUpdateCurrentTime)
        }
    }

    @Override
    protected override fun onDetachedFromWindow() {
        cleanup()
        super.onDetachedFromWindow()
    }

    internal inner class DismissPopup : Runnable {
        override fun run() {
            // Protect against null-pointer exceptions
            if (mPopup != null) {
                mPopup?.dismiss()
            }
        }
    }

    internal inner class UpdateCurrentTime : Runnable {
        override fun run() {
            val currentTime: Long = System.currentTimeMillis()
            mCurrentTime?.set(currentTime)
            // % causes update to occur on 5 minute marks (11:10, 11:15, 11:20, etc.)
            if (!mPaused) {
                mHandler?.postDelayed(
                    mUpdateCurrentTime, UPDATE_CURRENT_TIME_DELAY -
                        currentTime % UPDATE_CURRENT_TIME_DELAY
                )
            }
            mTodayJulianDay = Time.getJulianDay(currentTime, mCurrentTime!!.gmtoff)
            invalidate()
        }
    }

    internal inner class CalendarGestureListener : GestureDetector.SimpleOnGestureListener() {
        @Override
        override fun onSingleTapUp(ev: MotionEvent): Boolean {
            if (DEBUG) Log.e(TAG, "GestureDetector.onSingleTapUp")
            doSingleTapUp(ev)
            return true
        }

        @Override
        override fun onLongPress(ev: MotionEvent) {
            if (DEBUG) Log.e(TAG, "GestureDetector.onLongPress")
            doLongPress(ev)
        }

        @Override
        override fun onScroll(
            e1: MotionEvent?,
            e2: MotionEvent,
            distanceX: Float,
            distanceY: Float
        ): Boolean {
            var distanceY = distanceY
            if (DEBUG) Log.e(TAG, "GestureDetector.onScroll")
            eventClickCleanup()
            if (mTouchStartedInAlldayArea) {
                if (Math.abs(distanceX) < Math.abs(distanceY)) {
                    // Make sure that click feedback is gone when you scroll from the
                    // all day area
                    invalidate()
                    return false
                }
                // don't scroll vertically if this started in the allday area
                distanceY = 0f
            }
            doScroll(e1, e2, distanceX, distanceY)
            return true
        }

        @Override
        override fun onFling(
            e1: MotionEvent?,
            e2: MotionEvent,
            velocityX: Float,
            velocityY: Float
        ): Boolean {
            var velocityY = velocityY
            if (DEBUG) Log.e(TAG, "GestureDetector.onFling")
            if (mTouchStartedInAlldayArea) {
                if (Math.abs(velocityX) < Math.abs(velocityY)) {
                    return false
                }
                // don't fling vertically if this started in the allday area
                velocityY = 0f
            }
            doFling(e1, e2, velocityX, velocityY)
            return true
        }

        @Override
        override fun onDown(ev: MotionEvent): Boolean {
            if (DEBUG) Log.e(TAG, "GestureDetector.onDown")
            doDown(ev)
            return true
        }
    }

    @Override
    override fun onLongClick(v: View?): Boolean {
        return true
    }

    private inner class ScrollInterpolator : Interpolator {
        override fun getInterpolation(t: Float): Float {
            var t = t
            t -= 1.0f
            t = t * t * t * t * t + 1
            if ((1 - t) * mAnimationDistance < 1) {
                cancelAnimation()
            }
            return t
        }
    }

    private fun calculateDuration(delta: Float, width: Float, velocity: Float): Long {
        /*
         * Here we compute a "distance" that will be used in the computation of
         * the overall snap duration. This is a function of the actual distance
         * that needs to be traveled; we keep this value close to half screen
         * size in order to reduce the variance in snap duration as a function
         * of the distance the page needs to travel.
         */
        var velocity = velocity
        val halfScreenSize = width / 2
        val distanceRatio = delta / width
        val distanceInfluenceForSnapDuration = distanceInfluenceForSnapDuration(distanceRatio)
        val distance = halfScreenSize + halfScreenSize * distanceInfluenceForSnapDuration
        velocity = Math.abs(velocity)
        velocity = Math.max(MINIMUM_SNAP_VELOCITY.toFloat(), velocity)

        /*
         * we want the page's snap velocity to approximately match the velocity
         * at which the user flings, so we scale the duration by a value near to
         * the derivative of the scroll interpolator at zero, ie. 5. We use 6 to
         * make it a little slower.
         */
        val duration: Long = 6L * Math.round(1000 * Math.abs(distance / velocity))
        if (DEBUG) {
            Log.e(
                TAG, "halfScreenSize:" + halfScreenSize + " delta:" + delta + " distanceRatio:" +
                    distanceRatio + " distance:" + distance + " velocity:" + velocity +
                    " duration:" + duration + " distanceInfluenceForSnapDuration:" +
                    distanceInfluenceForSnapDuration
            )
        }
        return duration
    }

    /*
     * We want the duration of the page snap animation to be influenced by the
     * distance that the screen has to travel, however, we don't want this
     * duration to be effected in a purely linear fashion. Instead, we use this
     * method to moderate the effect that the distance of travel has on the
     * overall snap duration.
     */
    private fun distanceInfluenceForSnapDuration(f: Float): Float {
        var f = f
        f -= 0.5f // center the values about 0.
        f *= (0.3f * Math.PI / 2.0f).toFloat()
        return Math.sin(f.toDouble()).toFloat()
    }

    companion object {
        private const val TAG = "DayView"
        private const val DEBUG = false
        private const val DEBUG_SCALING = false
        private const val PERIOD_SPACE = ". "
        private var mScale = 0f // Used for supporting different screen densities
        private const val INVALID_EVENT_ID: Long = -1 // This is used for remembering a null event

        // Duration of the allday expansion
        private const val ANIMATION_DURATION: Long = 400

        // duration of the more allday event text fade
        private const val ANIMATION_SECONDARY_DURATION: Long = 200

        // duration of the scroll to go to a specified time
        private const val GOTO_SCROLL_DURATION = 200

        // duration for events' cross-fade animation
        private const val EVENTS_CROSS_FADE_DURATION = 400

        // duration to show the event clicked
        private const val CLICK_DISPLAY_DURATION = 50
        private const val MENU_DAY = 3
        private const val MENU_EVENT_VIEW = 5
        private const val MENU_EVENT_CREATE = 6
        private const val MENU_EVENT_EDIT = 7
        private const val MENU_EVENT_DELETE = 8
        private var DEFAULT_CELL_HEIGHT = 64
        private var MAX_CELL_HEIGHT = 150
        private var MIN_Y_SPAN = 100
        private val CALENDARS_PROJECTION = arrayOf<String>(
            Calendars._ID, // 0
            Calendars.CALENDAR_ACCESS_LEVEL, // 1
            Calendars.OWNER_ACCOUNT
        )
        private const val CALENDARS_INDEX_ACCESS_LEVEL = 1
        private const val CALENDARS_INDEX_OWNER_ACCOUNT = 2
        private val CALENDARS_WHERE: String = Calendars._ID.toString() + "=%d"
        private const val FROM_NONE = 0
        private const val FROM_ABOVE = 1
        private const val FROM_BELOW = 2
        private const val FROM_LEFT = 4
        private const val FROM_RIGHT = 8
        private const val ACCESS_LEVEL_NONE = 0
        private const val ACCESS_LEVEL_DELETE = 1
        private const val ACCESS_LEVEL_EDIT = 2
        private var mHorizontalSnapBackThreshold = 128

        // Update the current time line every five minutes if the window is left open that long
        private const val UPDATE_CURRENT_TIME_DELAY = 300000
        private var mOnDownDelay = 0
        protected var mStringBuilder: StringBuilder = StringBuilder(50)

        // TODO recreate formatter when locale changes
        protected var mFormatter: Formatter = Formatter(mStringBuilder, Locale.getDefault())

        // The number of milliseconds to show the popup window
        private const val POPUP_DISMISS_DELAY = 3000
        private var GRID_LINE_LEFT_MARGIN = 0f
        private const val GRID_LINE_INNER_WIDTH = 1f
        private const val DAY_GAP = 1
        private const val HOUR_GAP = 1

        // This is the standard height of an allday event with no restrictions
        private var SINGLE_ALLDAY_HEIGHT = 34

        /**
         * This is the minimum desired height of a allday event.
         * When unexpanded, allday events will use this height.
         * When expanded allDay events will attempt to grow to fit all
         * events at this height.
         */
        private var MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT = 28.0f // in pixels

        /**
         * This is how big the unexpanded allday height is allowed to be.
         * It will get adjusted based on screen size
         */
        private var MAX_UNEXPANDED_ALLDAY_HEIGHT = (MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT * 4).toInt()

        /**
         * This is the minimum size reserved for displaying regular events.
         * The expanded allDay region can't expand into this.
         */
        private const val MIN_HOURS_HEIGHT = 180
        private var ALLDAY_TOP_MARGIN = 1

        // The largest a single allDay event will become.
        private var MAX_HEIGHT_OF_ONE_ALLDAY_EVENT = 34
        private var HOURS_TOP_MARGIN = 2
        private var HOURS_LEFT_MARGIN = 2
        private var HOURS_RIGHT_MARGIN = 4
        private var HOURS_MARGIN = HOURS_LEFT_MARGIN + HOURS_RIGHT_MARGIN
        private var NEW_EVENT_MARGIN = 4
        private var NEW_EVENT_WIDTH = 2
        private var NEW_EVENT_MAX_LENGTH = 16
        private var CURRENT_TIME_LINE_SIDE_BUFFER = 4
        private var CURRENT_TIME_LINE_TOP_OFFSET = 2

        /* package */
        const val MINUTES_PER_HOUR = 60

        /* package */
        const val MINUTES_PER_DAY = MINUTES_PER_HOUR * 24

        /* package */
        const val MILLIS_PER_MINUTE = 60 * 1000

        /* package */
        const val MILLIS_PER_HOUR = 3600 * 1000

        /* package */
        const val MILLIS_PER_DAY = MILLIS_PER_HOUR * 24

        // More events text will transition between invisible and this alpha
        private const val MORE_EVENTS_MAX_ALPHA = 0x4C
        private var DAY_HEADER_ONE_DAY_LEFT_MARGIN = 0
        private var DAY_HEADER_ONE_DAY_RIGHT_MARGIN = 5
        private var DAY_HEADER_ONE_DAY_BOTTOM_MARGIN = 6
        private var DAY_HEADER_RIGHT_MARGIN = 4
        private var DAY_HEADER_BOTTOM_MARGIN = 3
        private var DAY_HEADER_FONT_SIZE = 14f
        private var DATE_HEADER_FONT_SIZE = 32f
        private var NORMAL_FONT_SIZE = 12f
        private var EVENT_TEXT_FONT_SIZE = 12f
        private var HOURS_TEXT_SIZE = 12f
        private var AMPM_TEXT_SIZE = 9f
        private var MIN_HOURS_WIDTH = 96
        private var MIN_CELL_WIDTH_FOR_TEXT = 20
        private const val MAX_EVENT_TEXT_LEN = 500

        // smallest height to draw an event with
        private var MIN_EVENT_HEIGHT = 24.0f // in pixels
        private var CALENDAR_COLOR_SQUARE_SIZE = 10
        private var EVENT_RECT_TOP_MARGIN = 1
        private var EVENT_RECT_BOTTOM_MARGIN = 0
        private var EVENT_RECT_LEFT_MARGIN = 1
        private var EVENT_RECT_RIGHT_MARGIN = 0
        private var EVENT_RECT_STROKE_WIDTH = 2
        private var EVENT_TEXT_TOP_MARGIN = 2
        private var EVENT_TEXT_BOTTOM_MARGIN = 2
        private var EVENT_TEXT_LEFT_MARGIN = 6
        private var EVENT_TEXT_RIGHT_MARGIN = 6
        private var ALL_DAY_EVENT_RECT_BOTTOM_MARGIN = 1
        private var EVENT_ALL_DAY_TEXT_TOP_MARGIN = EVENT_TEXT_TOP_MARGIN
        private var EVENT_ALL_DAY_TEXT_BOTTOM_MARGIN = EVENT_TEXT_BOTTOM_MARGIN
        private var EVENT_ALL_DAY_TEXT_LEFT_MARGIN = EVENT_TEXT_LEFT_MARGIN
        private var EVENT_ALL_DAY_TEXT_RIGHT_MARGIN = EVENT_TEXT_RIGHT_MARGIN

        // margins and sizing for the expand allday icon
        private var EXPAND_ALL_DAY_BOTTOM_MARGIN = 10

        // sizing for "box +n" in allDay events
        private var EVENT_SQUARE_WIDTH = 10
        private var EVENT_LINE_PADDING = 4
        private var NEW_EVENT_HINT_FONT_SIZE = 12
        private var mEventTextColor = 0
        private var mMoreEventsTextColor = 0
        private var mWeek_saturdayColor = 0
        private var mWeek_sundayColor = 0
        private var mCalendarDateBannerTextColor = 0
        private var mCalendarAmPmLabel = 0
        private var mCalendarGridAreaSelected = 0
        private var mCalendarGridLineInnerHorizontalColor = 0
        private var mCalendarGridLineInnerVerticalColor = 0
        private var mFutureBgColor = 0
        private var mFutureBgColorRes = 0
        private var mBgColor = 0
        private var mNewEventHintColor = 0
        private var mCalendarHourLabelColor = 0
        private var mMoreAlldayEventsTextAlpha = MORE_EVENTS_MAX_ALPHA
        private var mCellHeight = 0 // shared among all DayViews
        private var mMinCellHeight = 32
        private var mScaledPagingTouchSlop = 0

        /**
         * Whether to use the expand or collapse icon.
         */
        private var mUseExpandIcon = true

        /**
         * The height of the day names/numbers
         */
        private var DAY_HEADER_HEIGHT = 45

        /**
         * The height of the day names/numbers for multi-day views
         */
        private var MULTI_DAY_HEADER_HEIGHT = DAY_HEADER_HEIGHT

        /**
         * The height of the day names/numbers when viewing a single day
         */
        private var ONE_DAY_HEADER_HEIGHT = DAY_HEADER_HEIGHT

        /**
         * Whether or not to expand the allDay area to fill the screen
         */
        private var mShowAllAllDayEvents = false
        private var sCounter = 0

        /**
         * The initial state of the touch mode when we enter this view.
         */
        private const val TOUCH_MODE_INITIAL_STATE = 0

        /**
         * Indicates we just received the touch event and we are waiting to see if
         * it is a tap or a scroll gesture.
         */
        private const val TOUCH_MODE_DOWN = 1

        /**
         * Indicates the touch gesture is a vertical scroll
         */
        private const val TOUCH_MODE_VSCROLL = 0x20

        /**
         * Indicates the touch gesture is a horizontal scroll
         */
        private const val TOUCH_MODE_HSCROLL = 0x40

        /**
         * The selection modes are HIDDEN, PRESSED, SELECTED, and LONGPRESS.
         */
        private const val SELECTION_HIDDEN = 0
        private const val SELECTION_PRESSED = 1 // D-pad down but not up yet
        private const val SELECTION_SELECTED = 2
        private const val SELECTION_LONGPRESS = 3

        // The rest of this file was borrowed from Launcher2 - PagedView.java
        private const val MINIMUM_SNAP_VELOCITY = 2200
    }

    init {
        mContext = context
        initAccessibilityVariables()
        mResources = context!!.getResources()
        mNewEventHintString = mResources.getString(R.string.day_view_new_event_hint)
        mNumDays = numDays
        DATE_HEADER_FONT_SIZE =
            mResources.getDimension(R.dimen.date_header_text_size).toInt().toFloat()
        DAY_HEADER_FONT_SIZE =
            mResources.getDimension(R.dimen.day_label_text_size).toInt().toFloat()
        ONE_DAY_HEADER_HEIGHT = mResources.getDimension(R.dimen.one_day_header_height).toInt()
        DAY_HEADER_BOTTOM_MARGIN = mResources.getDimension(R.dimen.day_header_bottom_margin).toInt()
        EXPAND_ALL_DAY_BOTTOM_MARGIN =
            mResources.getDimension(R.dimen.all_day_bottom_margin).toInt()
        HOURS_TEXT_SIZE = mResources.getDimension(R.dimen.hours_text_size).toInt().toFloat()
        AMPM_TEXT_SIZE = mResources.getDimension(R.dimen.ampm_text_size).toInt().toFloat()
        MIN_HOURS_WIDTH = mResources.getDimension(R.dimen.min_hours_width).toInt()
        HOURS_LEFT_MARGIN = mResources.getDimension(R.dimen.hours_left_margin).toInt()
        HOURS_RIGHT_MARGIN = mResources.getDimension(R.dimen.hours_right_margin).toInt()
        MULTI_DAY_HEADER_HEIGHT = mResources.getDimension(R.dimen.day_header_height).toInt()
        val eventTextSizeId: Int
        eventTextSizeId = if (mNumDays == 1) {
            R.dimen.day_view_event_text_size
        } else {
            R.dimen.week_view_event_text_size
        }
        EVENT_TEXT_FONT_SIZE = mResources.getDimension(eventTextSizeId).toFloat()
        NEW_EVENT_HINT_FONT_SIZE = mResources.getDimension(R.dimen.new_event_hint_text_size).toInt()
        MIN_EVENT_HEIGHT = mResources.getDimension(R.dimen.event_min_height)
        MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT = MIN_EVENT_HEIGHT
        EVENT_TEXT_TOP_MARGIN = mResources.getDimension(R.dimen.event_text_vertical_margin).toInt()
        EVENT_TEXT_BOTTOM_MARGIN = EVENT_TEXT_TOP_MARGIN
        EVENT_ALL_DAY_TEXT_TOP_MARGIN = EVENT_TEXT_TOP_MARGIN
        EVENT_ALL_DAY_TEXT_BOTTOM_MARGIN = EVENT_TEXT_TOP_MARGIN
        EVENT_TEXT_LEFT_MARGIN = mResources
            .getDimension(R.dimen.event_text_horizontal_margin).toInt()
        EVENT_TEXT_RIGHT_MARGIN = EVENT_TEXT_LEFT_MARGIN
        EVENT_ALL_DAY_TEXT_LEFT_MARGIN = EVENT_TEXT_LEFT_MARGIN
        EVENT_ALL_DAY_TEXT_RIGHT_MARGIN = EVENT_TEXT_LEFT_MARGIN
        if (mScale == 0f) {
            mScale = mResources.getDisplayMetrics().density
            if (mScale != 1f) {
                SINGLE_ALLDAY_HEIGHT *= mScale.toInt()
                ALLDAY_TOP_MARGIN *= mScale.toInt()
                MAX_HEIGHT_OF_ONE_ALLDAY_EVENT *= mScale.toInt()
                NORMAL_FONT_SIZE *= mScale
                GRID_LINE_LEFT_MARGIN *= mScale
                HOURS_TOP_MARGIN *= mScale.toInt()
                MIN_CELL_WIDTH_FOR_TEXT *= mScale.toInt()
                MAX_UNEXPANDED_ALLDAY_HEIGHT *= mScale.toInt()
                mAnimateDayEventHeight = MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT.toInt()
                CURRENT_TIME_LINE_SIDE_BUFFER *= mScale.toInt()
                CURRENT_TIME_LINE_TOP_OFFSET *= mScale.toInt()
                MIN_Y_SPAN *= mScale.toInt()
                MAX_CELL_HEIGHT *= mScale.toInt()
                DEFAULT_CELL_HEIGHT *= mScale.toInt()
                DAY_HEADER_HEIGHT *= mScale.toInt()
                DAY_HEADER_RIGHT_MARGIN *= mScale.toInt()
                DAY_HEADER_ONE_DAY_LEFT_MARGIN *= mScale.toInt()
                DAY_HEADER_ONE_DAY_RIGHT_MARGIN *= mScale.toInt()
                DAY_HEADER_ONE_DAY_BOTTOM_MARGIN *= mScale.toInt()
                CALENDAR_COLOR_SQUARE_SIZE *= mScale.toInt()
                EVENT_RECT_TOP_MARGIN *= mScale.toInt()
                EVENT_RECT_BOTTOM_MARGIN *= mScale.toInt()
                ALL_DAY_EVENT_RECT_BOTTOM_MARGIN *= mScale.toInt()
                EVENT_RECT_LEFT_MARGIN *= mScale.toInt()
                EVENT_RECT_RIGHT_MARGIN *= mScale.toInt()
                EVENT_RECT_STROKE_WIDTH *= mScale.toInt()
                EVENT_SQUARE_WIDTH *= mScale.toInt()
                EVENT_LINE_PADDING *= mScale.toInt()
                NEW_EVENT_MARGIN *= mScale.toInt()
                NEW_EVENT_WIDTH *= mScale.toInt()
                NEW_EVENT_MAX_LENGTH *= mScale.toInt()
            }
        }
        HOURS_MARGIN = HOURS_LEFT_MARGIN + HOURS_RIGHT_MARGIN
        DAY_HEADER_HEIGHT = if (mNumDays == 1) ONE_DAY_HEADER_HEIGHT else MULTI_DAY_HEADER_HEIGHT
        mCurrentTimeLine = mResources.getDrawable(R.drawable.timeline_indicator_holo_light)
        mCurrentTimeAnimateLine = mResources
            .getDrawable(R.drawable.timeline_indicator_activated_holo_light)
        mTodayHeaderDrawable = mResources.getDrawable(R.drawable.today_blue_week_holo_light)
        mExpandAlldayDrawable = mResources.getDrawable(R.drawable.ic_expand_holo_light)
        mCollapseAlldayDrawable = mResources.getDrawable(R.drawable.ic_collapse_holo_light)
        mNewEventHintColor = mResources.getColor(R.color.new_event_hint_text_color)
        mAcceptedOrTentativeEventBoxDrawable = mResources
            .getDrawable(R.drawable.panel_month_event_holo_light)
        mEventLoader = eventLoader as EventLoader
        mEventGeometry = EventGeometry()
        mEventGeometry.setMinEventHeight(MIN_EVENT_HEIGHT)
        mEventGeometry.setHourGap(HOUR_GAP.toFloat())
        mEventGeometry.setCellMargin(DAY_GAP)
        mLastPopupEventID = INVALID_EVENT_ID
        mController = controller as CalendarController
        mViewSwitcher = viewSwitcher as ViewSwitcher
        mGestureDetector = GestureDetector(context, CalendarGestureListener())
        mScaleGestureDetector = ScaleGestureDetector(getContext(), this)
        if (mCellHeight == 0) {
            mCellHeight = Utils.getSharedPreference(
                mContext,
                GeneralPreferences.KEY_DEFAULT_CELL_HEIGHT, DEFAULT_CELL_HEIGHT
            )
        }
        mScroller = OverScroller(context)
        mHScrollInterpolator = ScrollInterpolator()
        mEdgeEffectTop = EdgeEffect(context)
        mEdgeEffectBottom = EdgeEffect(context)
        val vc: ViewConfiguration = ViewConfiguration.get(context)
        mScaledPagingTouchSlop = vc.getScaledPagingTouchSlop()
        mOnDownDelay = ViewConfiguration.getTapTimeout()
        OVERFLING_DISTANCE = vc.getScaledOverflingDistance()
        init(context as Context)
    }
}