PDF_Office/PDF Office/PDF Master/Class/PDFTools/Watermark/View/KMWatermarkPDFView.swift

//
//  KMWatermarkPDFView.swift
//  PDF Master
//
//  Created by tangchao on 2022/12/19.
//

import Cocoa

class KMWatermarkPDFView: CPDFView {
    
//    var watermarkModel: KMWatermarkModel!
    
    var watermark: KMWatermarkModel = KMWatermarkModel()
    var background: KMBackgroundModel = KMBackgroundModel()
    var headerFooter: KMHeaderFooterModel = KMHeaderFooterModel()
    
    override func draw(_ page: CPDFPage!, to context: CGContext!) {
        if (self.watermark == nil) {
            super.draw(page, to: context)
            return 
        }
        
        if (self.watermark.isFront) {
            super.draw(page, to: context)
            
            if (self.needDraw(page)) {
                drawWatermarkPage(page, to: context)
            }
        } else {
            if (self.needDraw(page)) {
                drawWatermarkPage(page, to: context)
            }
            
            super.draw(page, to: context)
        }
    }
    
    func needDraw(_ page: CPDFPage) -> Bool {
        if (self.watermark == nil) {
            return true
        }
        
        if (self.watermark.pageRangeType.rawValue == 0) {
            return true
        }
//        else if (self.watermarkModel.pageRangeType == 1) {
//            let array = self.watermarkModel.pagesString.components(separatedBy: ",")
//            let index: Int = Int(self.document.index(for: page))
//            if (!array.contains("\(index+1)")) {
//                return false
//            }
//        }
        else if (self.watermark.pageRangeType == .odd) {
            let index: Int = Int(self.document.index(for: page))
            return (index % 2 == 0)
        } else if (self.watermark.pageRangeType == .even) {
            let index: Int = Int(self.document.index(for: page))
            return (index % 2 == 1)
        } else if (self.watermark.pageRangeType == .other) {
            if (self.watermark.pagesString.isEmpty) {
                return false
            }
            
            let array = self.watermark.pagesString.components(separatedBy: ",")
            let index: Int = Int(self.document.index(for: page))
            if (!array.contains("\(index+1)")) {
                return false
            }
        }
        
        return true
    }
    
    func drawWatermarkPage(_ page: CPDFPage, to context: CGContext) {
        let pageBounds = page.bounds(for: .cropBox)
        let w: CGFloat = NSWidth(pageBounds)
        let h: CGFloat = NSHeight(pageBounds)
        
        let width: CGFloat = sqrt(w*w+h*h)
        let newRect: CGRect = CGRect(x: -(width-w)*0.5, y: -(width-h)*0.5, width: width, height: width)
        let new_w: CGFloat = NSWidth(newRect)
        let new_h: CGFloat = NSHeight(newRect)
        
        if (context != nil) {
            NSGraphicsContext.current = NSGraphicsContext(cgContext: context, flipped: false)
        }
        NSGraphicsContext.saveGraphicsState()
        page.transform(context, for: .cropBox)
        if (self.watermark.pagesString.count > 0) {
            let array = self.watermark.pagesString.components(separatedBy: ",")
            let index: Int = Int(self.document.index(for: page))
            if (!array.contains("\(index)")) {
                return
            }
        }
        
        if (!self.watermark.text.isEmpty) {
            var font = self.watermark.getTextFont()
            if (font == nil) {
                font = NSFont(name: "Helvetica", size: 48)!
            }
            
            var color = NSColor.black
            if (self.watermark.textColor != nil) {
                color = self.watermark.getTextColor()
            }
            
            var red: CGFloat = 0
            var green: CGFloat = 0
            var blue: CGFloat = 0
            color.usingColorSpaceName(NSColorSpaceName.calibratedRGB)?.getRed(&red, green: &green, blue: &blue, alpha: nil)
            color = NSColor(red: red, green: green, blue: blue, alpha: self.watermark.opacity)
            
            var size = NSZeroSize
            let style = NSMutableParagraphStyle()
            style.alignment = self.watermark.textAligement
            style.lineBreakMode = .byCharWrapping
            let dict = [
                NSAttributedString.Key.paragraphStyle : style,
                        NSAttributedString.Key.foregroundColor : color,
//                        NSAttributedString.Key.font : font as Any
            ] as [NSAttributedString.Key : Any]
            size = self.watermark.text.boundingRect(with: NSSize(width: 1000, height: 1000), options: NSString.DrawingOptions(rawValue: 3), attributes: dict).size
            
            let radian: CGFloat = self.watermark.rotation*(Double.pi/180.0)
            let t: CGAffineTransform = CGAffineTransform(rotationAngle: radian)
            var rect:CGRect = CGRect(x: 0, y: 0, width: size.width, height: size.height)
            
            if (self.watermark.isTilePage) {
                context.translateBy(x: w * 0.5, y: h * 0.5)
                context.concatenate(t)
                context.translateBy(x: -(w/2),  y: -(h/2))
                
                let verticalWidth: CGFloat = size.width + self.watermark.tileHorizontalSpace
                let horizontalHeight: CGFloat = size.height + self.watermark.tileVerticalSpace
                let line: Int = Int(((new_h-self.watermark.tileVerticalSpace)/horizontalHeight)+1)
                let row: Int = Int(((new_w-self.watermark.tileHorizontalSpace)/verticalWidth)+1)
                
                let point: CGPoint = CGPoint(x: w*0.5-size.width*0.5+self.watermark.horizontalSpace, y: h*0.5-size.height*0.5+self.watermark.verticalSpace)
                for i in 0 ..< line {
                    for j in 0 ..< row {
                        self.watermark.text.draw(in: NSRect(x: point.x+CGFloat(j)*verticalWidth, y: point.y+CGFloat(i)*horizontalHeight, width: size.width, height: size.height), withAttributes: dict)
                    }
                }
                
                for i in 1 ..< line {
                    for j in 0 ..< row {
                        self.watermark.text.draw(in: NSRect(x: point.x+CGFloat(j)*verticalWidth, y: point.y-CGFloat(i)*horizontalHeight, width: size.width, height: size.height), withAttributes: dict)
                    }
                }
                
                for i in 0 ..< line {
                    for j in 1 ..< row {
                        self.watermark.text.draw(in: NSRect(x: point.x-CGFloat(j)*verticalWidth, y: point.y+CGFloat(i)*horizontalHeight, width: size.width, height: size.height), withAttributes: dict)
                    }
                }
                
                for i in 1 ..< line {
                    for j in 1 ..< row {
                        self.watermark.text.draw(in: NSRect(x: point.x-CGFloat(j)*verticalWidth, y: point.y-CGFloat(i)*horizontalHeight, width: size.width, height: size.height), withAttributes: dict)
                    }
                }
            } else {
                if (self.watermark.verticalMode == 0) {
                    rect.origin.y = pageBounds.size.height-rect.size.height
                } else if (self.watermark.verticalMode == 1) {
                    rect.origin.y = (pageBounds.size.height-rect.size.height) * 0.5
                } else {
                    rect.origin.y = 0
                }
                
                if (self.watermark.horizontalMode == 0) {
                    rect.origin.x = 0
                } else if (self.watermark.horizontalMode == 1) {
                    rect.origin.x = (pageBounds.size.width-rect.size.width) * 0.5
                } else {
                    rect.origin.x = pageBounds.size.width-rect.size.width
                }
                
                rect.origin.x += self.watermark.horizontalSpace
                rect.origin.y += self.watermark.verticalSpace
                
                let contextCenter = CGPoint(x: rect.midX, y: rect.midY)
                context.translateBy(x: contextCenter.x, y: contextCenter.y)
                context.rotate(by: radian)
                context.translateBy(x: -contextCenter.x, y: -contextCenter.y)
                
                self.watermark.text.draw(in: rect, withAttributes: dict)
            }
        } else if (self.watermark.image != nil) {
            let tiffData = self.watermark.image.tiffRepresentation
            let bitmap: NSBitmapImageRep!
            bitmap = NSBitmapImageRep(data: tiffData!)
            let ciImage = CIImage(bitmapImageRep: bitmap)
            var size: NSSize = (ciImage?.extent.size)!
            size.width *= self.watermark.scale
            size.height *= self.watermark.scale
            
            let radian = self.watermark.rotation * (Double.pi / 180.0)
            let t: CGAffineTransform = CGAffineTransform(rotationAngle: radian)
            var rect = NSMakeRect(0, 0, size.width, size.height)
            if (self.watermark.isTilePage) {
                context.translateBy(x: w/2,y: h/2)
                context.concatenate(t)
                context.translateBy(x: -(w/2),  y: -(h/2))
                
                let verticalWidth: CGFloat = size.width + self.watermark.tileHorizontalSpace
                let horizontalHeight: CGFloat = size.height + self.watermark.tileVerticalSpace
                let line: Int = Int((new_h - self.watermark.tileVerticalSpace)/horizontalHeight + 1)
                let row: Int = Int((new_w - self.watermark.tileHorizontalSpace) / verticalWidth + 1)
                let point = NSPoint(x: w/2 - size.width/2, y: h/2 - size.height/2)
                for i in 0 ..< (line/2+1) {
                    for j in 0 ..< row {
                        let area = CGRect(x: point.x  + CGFloat(j) * verticalWidth, y: point.y + CGFloat(i)*horizontalHeight, width: size.width, height: size.height)
                        self.watermark.image.draw(in: area, from: NSZeroRect, operation: .overlay, fraction: self.watermark.opacity)
                    }
                }
                
                for i in 1 ..< (line/2+1) {
                    for j in 0 ..< row {
                        let area = CGRect(x: point.x  + CGFloat(j) * verticalWidth, y: point.y - CGFloat(i)*horizontalHeight, width: size.width, height: size.height)
                        self.watermark.image.draw(in: area, from: NSZeroRect, operation: .overlay, fraction: self.watermark.opacity)
                    }
                }
                
                for i in 0 ..< (line/2+1) {
                    for j in 1 ..< row {
                        let area = CGRect(x: point.x  - CGFloat(j) * verticalWidth, y: point.y + CGFloat(i)*horizontalHeight, width: size.width, height: size.height)
                        self.watermark.image.draw(in: area, from: NSZeroRect, operation: .overlay, fraction: self.watermark.opacity)
                    }
                }
                
                for i in 1 ..< (line/2+1) {
                    for j in 1 ..< row {
                        let area = CGRect(x: point.x  - CGFloat(j) * verticalWidth, y: point.y - CGFloat(i)*horizontalHeight, width: size.width, height: size.height)
                        self.watermark.image.draw(in: area, from: NSZeroRect, operation: .overlay, fraction: self.watermark.opacity)
                    }
                }
            } else {
                if (self.watermark.verticalMode == 0) {
                    rect.origin.y = pageBounds.size.height-rect.size.height
                } else if (self.watermark.verticalMode == 1) {
                    rect.origin.y = (pageBounds.size.height-rect.size.height) * 0.5
                } else {
                    rect.origin.y = 0
                }
                
                if (self.watermark.horizontalMode == 0) {
                    rect.origin.x = 0
                } else if (self.watermark.horizontalMode == 1) {
                    rect.origin.x = (pageBounds.size.width-rect.size.width) * 0.5
                } else {
                    rect.origin.x = pageBounds.size.width-rect.size.width
                }
                
                rect.origin.x += self.watermark.horizontalSpace
                rect.origin.y += self.watermark.verticalSpace
                
                let contextCenter = CGPoint(x: rect.midX, y: rect.midY)
                context.translateBy(x: contextCenter.x, y: contextCenter.y)
                context.rotate(by: radian)
                context.translateBy(x: -contextCenter.x, y: -contextCenter.y)
                
                self.watermark.image.draw(in: rect, from: NSZeroRect, operation: .overlay, fraction: self.watermark.opacity)
            }
        }
        NSGraphicsContext.restoreGraphicsState()
    }
}