//
//  LoRes.swift
//  A2Mac
//
//  Created by Tamas Rudnai on 9/19/19.
//  Copyright © 2019 GameAlloy. All rights reserved.
//

//import Foundation
import AppKit

class LoRes: NSView {
    
    static let PageSize  = 0x400
    static let Page1Addr = 0x400
    static let Page2Addr = 0x800
    
    static let PixelWidth  = 40
    static let PixelMixedHeight = 40
    static let PixelHeight = 48
    static let MixedTextHeight = 4
    static let blockRows = 24
    static let blockCols = 40
    static let blockWidth = PixelWidth / blockCols
    static let blockHeight = PixelHeight / blockRows

    let LoResBuffer1 = UnsafeRawBufferPointer(start: MEM + Page1Addr, count: PageSize * 2)
    let LoResBuffer2 = UnsafeRawBufferPointer(start: MEM + Page2Addr, count: PageSize * 2)
    var LoResBufferPointer = UnsafeRawBufferPointer(start: MEM + Page1Addr, count: PageSize * 2)
    
    let LoResRawPointer = UnsafeRawPointer(RAM + Page1Addr)

    // holds the starting addresses for each lines minus the screen page starting address
    var LoResLineAddrTbl = [Int](repeating: 0, count: PixelHeight * 4)

    func initLoResLineAddresses() {
        var i = 0
        for x in stride(from: 0, through: 0x50, by: 0x28) {
            for y in stride(from: 0, through: 0x380, by: 0x80) {
                for z in stride(from: 0, through: 0x1C00, by: 0x400) {
                    LoResLineAddrTbl[i] = x + y + z
                    i += 1
                }
            }
        }
    }
    
    
    var LoResSubView = [[NSView]]()
    
    func createLoRes() {
        for y in 0 ..< LoRes.blockRows {
            LoResSubView.append([NSView]())
            for x in 0 ..< LoRes.blockCols {
                let blockView = NSView(frame: NSRect(x: x * LoRes.blockWidth, y: y * 8, width: LoRes.blockWidth, height: 8))
                LoResSubView[y].append(blockView)
                self.addSubview(blockView)
            }
        }
    }
    
    
    func clearScreen() {
        LoRes.context?.clear( CGRect(x: 0, y: 0, width: frame.width, height: frame.height) )
        needsDisplay = true
    }


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

//        currentContext?.setShouldAntialias(false)
//        currentContext?.interpolationQuality = CGInterpolationQuality.none
        
//        let scaleSizeW = Double((frame.size).width) / Double(LoRes.PixelWidth)
//        let scaleSizeH = Double((frame.size).height) / Double(LoRes.PixelHeight)

//        let scaleSizeW = 4
//        let scaleSizeH = 4
//        scaleUnitSquare(to: NSSize(width: scaleSizeW, height: scaleSizeH))
        
        // create smaller box views for draw optimization
        createLoRes()
        
    }
    
    override init(frame: CGRect) {
        super.init(frame: frame)
    }
    
    

    func renderCallback(displayLink : CVDisplayLink,
                               const  inNow : UnsafePointer<CVTimeStamp>,
                               const  inOutputTime : UnsafePointer<CVTimeStamp>,
                               flagsIn : CVOptionFlags,
                               flagsOut : UnsafeMutablePointer<CVOptionFlags>,
                               displayLinkContext : UnsafeMutableRawPointer) -> CVReturn
    {
        /*  It's prudent to also have a brief discussion about the CVTimeStamp.
            CVTimeStamp has five properties.  Three of the five are very useful
            for keeping track of the current time, calculating delta time, the
            frame number, and the number of frames per second.  The utility of
            each property is not terribly obvious from just reading the names
            or the descriptions in the Developer dcumentation and has been a
            mystery to many a developer.  Thankfully, CaptainRedmuff on
            StackOverflow asked a question that provided the equation that
            calculates frames per second.  From that equation, we can
            extrapolate the value of each field.

            @hostTime = current time in Units of the "root".  Yeah, I don't know.
              The key to this field is to understand that it is in nanoseconds
              (e.g. 1/1_000_000_000 of a second) not units.  To convert it to
              seconds divide by 1_000_000_000.  Dividing by videoRefreshPeriod
              and videoTimeScale in a calculation for frames per second yields
              the appropriate number of frames.  This works as a result of
              proportionality--dividing seconds by seconds.  Note that dividing
              by videoTimeScale to get the time in seconds does not work like it
              does for videoTime.

              framesPerSecond:
                (videoTime / videoRefreshPeriod) / (videoTime / videoTimeScale) = 59
              and
                (hostTime / videoRefreshPeriod) / (hostTime / videoTimeScale) = 59
              but
                hostTime * videoTimeScale ≠ seconds, but Units = seconds * (Units / seconds) = Units

          @rateScalar = ratio of "rate of device in CVTimeStamp/unitOfTime" to
            the "Nominal Rate".  I think the "Nominal Rate" is
            videoRefreshPeriod, but unfortunately, the documentation doesn't
            just say videoRefreshPeriod is the Nominal rate and then define
            what that means.  Regardless, because this is a ratio, and the fact
            that we know the value of one of the parts (e.g. Units/frame), we
            then know that the "rate of the device" is frame/Units (the units of
            measure need to cancel out for the ratio to be a ratio).  This
            makes sense in that rateScalar's definition tells us the rate is
            "measured by timeStamps".  Since there is a frame for every
            timeStamp, the rate of the device equals CVTimeStamp/Unit or
            frame/Unit.  Thus,

              rateScalar = frame/Units : Units/frame

          @videoTime = the time the frame was created since computer started up.
            If you turn your computer off and then turn it back on, this timer
            returns to zero.  The timer is paused when you put your computer to
            sleep.  This value is in Units not seconds.  To get the number of
            seconds this value represents, you have to apply videoTimeScale.

          @videoRefreshPeriod = the number of Units per frame (i.e. Units/frame)
            This is useful in calculating the frame number or frames per second.
            The documentation calls this the "nominal update period" and I am
            pretty sure that is quivalent to the aforementioned "nominal rate".
            Unfortunately, the documetation mixes naming conventions and this
            inconsistency creates confusion.

              frame = videoTime / videoRefreshPeriod

          @videoTimeScale = Units/second, used to convert videoTime into seconds
            and may also be used with videoRefreshPeriod to calculate the expected
            framesPerSecond.  I say expected, because videoTimeScale and
            videoRefreshPeriod don't change while videoTime does change.  Thus,
            to calculate fps in the case of system slow down, one would need to
            use videoTime with videoTimeScale to calculate the actual fps value.

              seconds = videoTime / videoTimeScale

              framesPerSecondConstant = videoTimeScale / videoRefreshPeriod (this value does not change if their is system slowdown)

        USE CASE 1: Time in DD:HH:mm:ss using hostTime
          let rootTotalSeconds = inNow.pointee.hostTime
          let rootDays = inNow.pointee.hostTime / (1_000_000_000 * 60 * 60 * 24) % 365
          let rootHours = inNow.pointee.hostTime / (1_000_000_000 * 60 * 60) % 24
          let rootMinutes = inNow.pointee.hostTime / (1_000_000_000 * 60) % 60
          let rootSeconds = inNow.pointee.hostTime / 1_000_000_000 % 60
          Swift.print("rootTotalSeconds: \(rootTotalSeconds) rootDays: \(rootDays) rootHours: \(rootHours) rootMinutes: \(rootMinutes) rootSeconds: \(rootSeconds)")

        USE CASE 2: Time in DD:HH:mm:ss using videoTime
          let totalSeconds = inNow.pointee.videoTime / Int64(inNow.pointee.videoTimeScale)
          let days = (totalSeconds / (60 * 60 * 24)) % 365
          let hours = (totalSeconds / (60 * 60)) % 24
          let minutes = (totalSeconds / 60) % 60
          let seconds = totalSeconds % 60
          Swift.print("totalSeconds: \(totalSeconds) Days: \(days) Hours: \(hours) Minutes: \(minutes) Seconds: \(seconds)")

          Swift.print("fps: \(Double(inNow.pointee.videoTimeScale) / Double(inNow.pointee.videoRefreshPeriod)) seconds: \(Double(inNow.pointee.videoTime) / Double(inNow.pointee.videoTimeScale))")
         */

        /*  The displayLinkContext in CVDisplayLinkOutputCallback's parameter list is the
            view being driven by the CVDisplayLink.  In order to use the context as an
            instance of SwiftOpenGLView (which has our drawView() method) we need to use
            unsafeBitCast() to cast this context to a SwiftOpenGLView.
         */

//        let view = unsafeBitCast(displayLinkContext, to: SwiftOpenGLView.self)
//        //  Capture the current time in the currentTime property.
//        view.currentTime = inNow.pointee.videoTime / Int64(inNow.pointee.videoTimeScale)
//        view.drawView()

//        self.render()
        
        return kCVReturnSuccess
    }
    
    static func createBitmapContext(pixelsWide: Int, _ pixelsHigh: Int) -> CGContext? {
        let bytesPerPixel = 4
        let bytesPerRow = bytesPerPixel * pixelsWide
        
        let byteCount = (bytesPerRow * pixelsHigh)
        
//        guard let colorSpace = CGColorSpace(name: CGColorSpace.linearSRGB) else { return nil }
//        guard let colorSpace = CGColorSpace(name: CGColorSpace.genericRGBLinear) else { return nil }
        guard let colorSpace = CGColorSpace(name: CGColorSpace.sRGB) else { return nil }

        let pixels = UnsafeMutablePointer<CUnsignedChar>.allocate(capacity: byteCount)

        let bitmapInfo = CGImageAlphaInfo.premultipliedFirst.rawValue | CGBitmapInfo.byteOrder32Little.rawValue
        
        let context = CGContext(
            data: pixels,
            width: pixelsWide,
            height: pixelsHigh,
            bitsPerComponent: 8,
            bytesPerRow: bytesPerRow,
            space: colorSpace,
            bitmapInfo: bitmapInfo)
        
        return context
    }
    

    private var currentContext : CGContext? {
        get {
            if #available(OSX 10.10, *) {
                return NSGraphicsContext.current?.cgContext
            } else if let contextPointer = NSGraphicsContext.current?.graphicsPort {
                let context: CGContext = Unmanaged.fromOpaque(contextPointer).takeUnretainedValue()
                return context
            }
            
            return nil
        }
    }

    static let ScreenBitmapSize = (PixelWidth * PixelHeight * 4)
    static let context = createBitmapContext(pixelsWide: PixelWidth, PixelHeight)
    static let pixels = UnsafeMutableRawBufferPointer(start: context?.data, count: ScreenBitmapSize)
    static var pixelsSRGB = pixels.bindMemory(to: UInt32.self)
    
    let R = 2
    let G = 1
    let B = 0
    let A = 3
    
    var blockChanged = [Bool](repeating: false, count: LoRes.blockRows * LoRes.blockCols)
    var shadowScreen = [Int](repeating: 0, count: PageSize)

    var was = 0;
    
    
//    static let color_black         : UInt32 = 0x00000000; //  0
//    static let color_magenta       : UInt32 = 0xFF660022; //  1
//    static let color_dark_blue     : UInt32 = 0xFF000077; //  2
//    static let color_purple        : UInt32 = 0xFF9908DD; //  3
//    static let color_dark_green    : UInt32 = 0xFF005500; //  4
//    static let color_dark_gray     : UInt32 = 0xFF333333; //  5
//    static let color_medium_blue   : UInt32 = 0xFF0011BB; //  6
//    static let color_light_blue    : UInt32 = 0xFF4488FF; //  7
//    static let color_brown         : UInt32 = 0xFF552200; //  8
//    static let color_orange        : UInt32 = 0xFFFF6611; //  9
//    static let color_gray          : UInt32 = 0xFF888888; // 10
//    static let color_pink          : UInt32 = 0xFFFF8888; // 11
//    static let color_green         : UInt32 = 0xFF0BBB11; // 12
//    static let color_yellow        : UInt32 = 0xFFFFFF00; // 13
//    static let color_aqua          : UInt32 = 0xFF66CC99; // 14
//    static let color_white         : UInt32 = 0xFFEEEEEE; // 15

    static let color_black         : UInt32 = 0x00000000; //  0
    static let color_magenta       : UInt32 = 0xFFDD0077; //  1
    static let color_dark_blue     : UInt32 = 0xFF0006F6; //  2
    static let color_purple        : UInt32 = 0xFFCC00FF; //  3
    static let color_dark_green    : UInt32 = 0xFF009800; //  4
    static let color_dark_gray     : UInt32 = 0xFF888888; //  5 // Darker only on //gs 
    static let color_medium_blue   : UInt32 = 0xFF006FFD; //  6
    static let color_light_blue    : UInt32 = 0xFF5AA3F0; //  7
    static let color_brown         : UInt32 = 0xFF5C341F; //  8
    static let color_orange        : UInt32 = 0xFFFF6302; //  9
    static let color_gray          : UInt32 = 0xFF888888; // 10
    static let color_pink          : UInt32 = 0xFFFF50B9; // 11
    static let color_green         : UInt32 = 0xFF2BD84A; // 12
    static let color_yellow        : UInt32 = 0xFFFFE700; // 13
    static let color_aqua          : UInt32 = 0xFF71EED6; // 14
    static let color_white         : UInt32 = 0xFFEEEEEE; // 15

    
    let colorTable = [
        color_black,
        color_magenta,
        color_dark_blue,
        color_purple,
        color_dark_green,
        color_dark_gray,
        color_medium_blue,
        color_light_blue,
        color_brown,
        color_orange,
        color_gray,
        color_pink,
        color_green,
        color_yellow,
        color_aqua,
        color_white
    ]
    
    // for debugging only:
    let color_turquis       : UInt32 = 0xFF11BBBB;
    let color_blue          : UInt32 = 0xFF1155FF;

    
    func colorPixel ( pixelAddr : Int, color : Int ) {
        LoRes.pixelsSRGB[pixelAddr] = colorTable[color]
    }

    
    func Update() {
        var height = LoRes.PixelHeight / 2
        
        // do not even render it...
        if videoMode.text == 1 {
            return
        }
        else {
            if videoMode.mixed == 1 {
                height = LoRes.PixelMixedHeight / 2
            }
            if MEMcfg.txt_page_2 == 1 {
                LoResBufferPointer = LoResBuffer2
            }
            else {
                LoResBufferPointer = LoResBuffer1
            }
        }
        
        var y = 0
        
        blockChanged = [Bool](repeating: false, count: LoRes.blockRows * LoRes.blockCols)
        
        LoRes.context?.clear( CGRect(x: 0, y: 0, width: frame.width, height: frame.height) )
        
        for lineAddr in ViewController.textLineOfs {
            
            if ( height <= 0 ) {
                break
            }
            height -= 1
            
            let blockVertIdx = y * LoRes.blockCols

            for blockHorIdx in 0 ..< LoRes.blockCols {
//                print("blockVertIdx:", blockVertIdx, "   blockHorIdx:", blockHorIdx)
                
                let block = Int(LoResBufferPointer[ Int(lineAddr + blockHorIdx) ])

                let screenIdx = blockVertIdx + blockHorIdx
                let pixelHAddr = blockVertIdx * 2 + blockHorIdx
                let pixelLAddr = pixelHAddr + LoRes.blockCols

                // get all changed blocks
                blockChanged[ screenIdx ] = blockChanged[ screenIdx ] || shadowScreen[ screenIdx ] != block
                shadowScreen[ screenIdx ] = block
                
                colorPixel(pixelAddr: pixelHAddr, color: block & 0x0F )
                colorPixel(pixelAddr: pixelLAddr, color: (block >> 4) & 0x0F )

            }
            y += 1
            
            if ( y >= LoRes.PixelHeight ) {
                break
            }
        }

        
        // refresh changed block only
        
        let screenBlockMargin = 6
        
        let blockScreenWidth = Int(frame.width) / LoRes.blockCols
        let blockScreenHeigth = Int(frame.height) / LoRes.blockRows

        for blockVertIdx in 0 ..< LoRes.blockRows {
            for blockHorIdx in 0 ..< LoRes.blockCols {
                if blockChanged[ blockVertIdx * LoRes.blockCols + blockHorIdx ] {
                    // refresh the entire screen
                    let boundingBox = CGRect(
                        x: blockHorIdx * blockScreenWidth - screenBlockMargin,
                        y: Int(frame.height) - blockVertIdx * blockScreenHeigth - blockScreenHeigth - screenBlockMargin,
                        width: blockScreenWidth + screenBlockMargin * 2,
                        height: blockScreenHeigth + screenBlockMargin * 2)
                    
                    self.setNeedsDisplay( boundingBox )
                }
            }
        }
        
//        needsDisplay = true // refresh the entire screen

    }
    
    override func draw(_ rect: CGRect) {
        guard let image = LoRes.context?.makeImage() else { return }

        // refresh the entire screen
        let boundingBox = CGRect(x: 0, y: 0, width: frame.width, height: frame.height)
        currentContext?.interpolationQuality = .none
        currentContext?.draw(image, in: boundingBox)
    }


    
}