//
//  RangeSlider.swift
//  RouteBuilder
//
//  Created by Sascha Simon on 26.11.16.
//  Copyright © 2016 Sascha Simon. All rights reserved.
//

import Foundation
import UIKit
import QuartzCore

@IBDesignable
class RangeSlider : UIControl
{
    let trackLayer = RangeSliderTrackLayer()
    let lowerThumbLayer = RangeSliderThumbLayer()
    let upperThumbLayer = RangeSliderThumbLayer()
    var previousLocation = CGPoint()

    var minimum: Double = 0.0
    {
        didSet
        {
            updateLayerFrames()
        }
    }

    var maximum: Double = 1.0
    {
        didSet
        {
            updateLayerFrames()
        }
    }

    var lowerValue: Double = 0.0
    {
        didSet
        {
            updateLayerFrames()
        }
    }

    var upperValue: Double = 1.0
    {
        didSet
        {
            updateLayerFrames()
        }
    }

    var trackTintColor: UIColor = UIColor(white: 0.9, alpha: 1.0)
    {
        didSet
        {
            trackLayer.setNeedsDisplay()
        }
    }

    var trackHighlightTintColor: UIColor = UIColor(red: 0.0, green: 0.45, blue: 0.94, alpha: 1.0)
    {
        didSet
        {
            trackLayer.setNeedsDisplay()
        }
    }

    var thumbTintColor: UIColor = UIColor.white
    {
        didSet
        {
            lowerThumbLayer.setNeedsDisplay()
            upperThumbLayer.setNeedsDisplay()
        }
    }

    var thumbWidth: CGFloat
    {
        return CGFloat(bounds.height)
    }

    override init(frame: CGRect)
    {
        super.init(frame: frame)

        trackLayer.rangeSlider = self
        trackLayer.contentsScale = UIScreen.main.scale
        layer.addSublayer(trackLayer)

        lowerThumbLayer.rangeSlider = self
        lowerThumbLayer.contentsScale = UIScreen.main.scale
        layer.addSublayer(lowerThumbLayer)

        upperThumbLayer.rangeSlider = self
        upperThumbLayer.contentsScale = UIScreen.main.scale
        layer.addSublayer(upperThumbLayer)
    }

    required init?(coder aDecoder: NSCoder)
    {
        super.init(coder: aDecoder)
    }

    func updateLayerFrames()
    {
        CATransaction.begin()
        CATransaction.setDisableActions(true)

        trackLayer.frame = self.bounds.insetBy(dx: 0.0, dy: bounds.height / 3)
        trackLayer.setNeedsDisplay()

        let lowerThumbCenter = CGFloat(positionForValue(lowerValue))

        lowerThumbLayer.frame = CGRect(x: lowerThumbCenter - thumbWidth / 2.0, y: 0.0,
                                       width: thumbWidth, height: thumbWidth)
        lowerThumbLayer.setNeedsDisplay()

        let upperThumbCenter = CGFloat(positionForValue(upperValue))
        upperThumbLayer.frame = CGRect(x: upperThumbCenter - thumbWidth / 2.0, y: 0.0,
                                       width: thumbWidth, height: thumbWidth)

        upperThumbLayer.setNeedsDisplay()

        CATransaction.commit()
    }

    func positionForValue(_ value: Double) -> Double
    {
        return Double(bounds.width - thumbWidth) * (value - minimum) / (maximum - minimum) + Double(thumbWidth / 2.0)
    }

    override var frame: CGRect
    {
        didSet
        {
            updateLayerFrames()
        }
    }

    override func beginTracking(_ touch: UITouch, with event: UIEvent?) -> Bool
    {
        previousLocation = touch.location(in: self)

        // Hit test the thumb layers
        if lowerThumbLayer.frame.contains(previousLocation)
        {
            lowerThumbLayer.highlighted = true
        } else if upperThumbLayer.frame.contains(previousLocation)
        {
            upperThumbLayer.highlighted = true
        }

        return lowerThumbLayer.highlighted || upperThumbLayer.highlighted
    }

    func boundValue(value: Double, toLowerValue lowerValue: Double, upperValue: Double) -> Double
    {
        return min(max(value, lowerValue), upperValue)
    }

    override func continueTracking(_ touch: UITouch, with event: UIEvent?) -> Bool
    {
        let location = touch.location(in: self)

        // Determine by how much the user has dragged
        let deltaLocation = Double(location.x - previousLocation.x)
        let deltaValue = (maximum - minimum) * deltaLocation / Double(bounds.width - thumbWidth)

        previousLocation = location

        // Update the values
        if lowerThumbLayer.highlighted
        {
            lowerValue += deltaValue
            lowerValue = boundValue(value: lowerValue, toLowerValue: minimum, upperValue: upperValue)
        }
        else if upperThumbLayer.highlighted
        {
            upperValue += deltaValue
            upperValue = boundValue(value: upperValue, toLowerValue: lowerValue, upperValue: maximum)
        }

        sendActions(for: .valueChanged)

        return true
    }

    override func endTracking(_ touch: UITouch?, with event: UIEvent?)
    {
        lowerThumbLayer.highlighted = false
        upperThumbLayer.highlighted = false
    }
}