//

// Euclid+Extensions.swift

// ShapeScript Lib

//

// Created by Nick Lockwood on 19/10/2021.

// Copyright © 2021 Nick Lockwood. All rights reserved.

//

import Euclid

public extension Collection where Element == Path {

/// Collective bounds for all paths

var bounds: Bounds {

reduce(into: .empty) { $0.formUnion($1.bounds) }

}

}

public extension Color {

init?(hexString: String) {

var string = hexString

if hexString.hasPrefix("#") {

string = String(string.dropFirst())

}

switch string.count {

case 3:

string += "f"

fallthrough

case 4:

let chars = Array(string)

let red = chars[0]

let green = chars[1]

let blue = chars[2]

let alpha = chars[3]

string = "\(red)\(red)\(green)\(green)\(blue)\(blue)\(alpha)\(alpha)"

case 6:

string += "ff"

case 8:

break

default:

return nil

}

guard let rgba = Double("0x" + string).flatMap({

UInt32(exactly: $0)

}) else {

return nil

}

let red = Double((rgba & 0xFF00_0000) >> 24) / 255

let green = Double((rgba & 0x00FF_0000) >> 16) / 255

let blue = Double((rgba & 0x0000_FF00) >> 8) / 255

let alpha = Double((rgba & 0x0000_00FF) >> 0) / 255

self.init(unchecked: [red, green, blue, alpha])

}

}

extension Color {

init(unchecked components: [Double]) {

if let color = Color(components) {

self = color

} else {

assertionFailure()

self = .clear

}

}

}

extension Angle {

var halfturns: Double {

radians / .pi

}

init(halfturns: Double) {

self.init(radians: halfturns * .pi)

}

static func halfturns(_ halfturns: Double) -> Angle {

self.init(halfturns: halfturns)

}

}

extension Rotation {

var rollYawPitchInHalfTurns: [Double] {

[roll.radians / .pi, yaw.radians / .pi, pitch.radians / .pi]

}

init?(rollYawPitchInHalfTurns: [Double]) {

var roll = 0.0, yaw = 0.0, pitch = 0.0

switch rollYawPitchInHalfTurns.count {

case 3:

pitch = rollYawPitchInHalfTurns[2]

fallthrough

case 2:

yaw = rollYawPitchInHalfTurns[1]

fallthrough

case 1:

roll = rollYawPitchInHalfTurns[0]

case 0:

break

default:

return nil

}

self.init(

roll: .radians(roll * .pi),

yaw: .radians(yaw * .pi),

pitch: .radians(pitch * .pi)

)

}

init(unchecked rollYawPitchInHalfTurns: [Double]) {

if let rotation = Rotation(rollYawPitchInHalfTurns: rollYawPitchInHalfTurns) {

self = rotation

} else {

assertionFailure()

self = .identity

}

}

}

#if canImport(UIKit)

import UIKit

#elseif canImport(AppKit)

import AppKit

#endif

#if canImport(CoreText)

private extension NSAttributedString {

convenience init(string: String, font: String?, color: Color?, linespacing: Double?) {

var fontName = (font ?? "Helvetica") as CFString

#if canImport(CoreGraphics)

fontName = CGFont(fontName)?.postScriptName ?? fontName

#endif

let font = CTFontCreateWithName(fontName as CFString, 1, nil)

var attributes = [NSAttributedString.Key.font: font as Any]

#if canImport(AppKit) || canImport(UIKit)

let paragraphStyle = NSMutableParagraphStyle()

paragraphStyle.lineSpacing = CGFloat(linespacing ?? 0)

attributes[.paragraphStyle] = paragraphStyle

attributes[.foregroundColor] = color.map(OSColor.init)

#endif

self.init(string: string, attributes: attributes)

}

}

#endif

extension Path {

/// Does path contain vertex colors

var hasColors: Bool {

points.contains(where: { $0.color != nil })

}

/// Create an array of text paths

static func text(

_ text: [TextValue],

width: Double? = nil,

detail: Int = 2

) -> [Path] {

#if canImport(CoreText)

let attributedString = NSMutableAttributedString()

for text in text {

var string = text.string

if attributedString.length > 0 {

string = "\n\(string)"

}

attributedString.append(NSAttributedString(

string: string,

font: text.font,

color: text.color,

linespacing: text.linespacing

))

}

return Path.text(attributedString, width: width, detail: detail)

#else

// TODO: throw error when CoreText not available

return []

#endif

}

/// Increase path detail in proportion to twist angle

func withDetail(_ detail: Int, twist: Angle) -> Path {

let subpaths = self.subpaths

guard subpaths.count == 1 else {

return Path(subpaths: subpaths.map {

$0.withDetail(detail, twist: twist)

})

}

guard var prev = points.first else {

return self

}

let total = length

let maxStep = Angle.twoPi / max(1, Double(detail / 2))

var split = false

let path = Path([prev] + points.dropFirst()

.flatMap { point -> [PathPoint] in

defer { prev = point }

let length = (point.position - prev.position).length

let step = twist * (length / total)

if step >= maxStep {

split = true

return [prev.lerp(point, 0.5).curved(), point]

}

return [point]

})

return split ? path.withDetail(detail, twist: twist) : path

}

}