ImageLinter.swift

#!/usr/bin/env xcrun --sdk macosx swift

import Foundation
import AppKit

/**
 ImageLinter.swift
 version 2.3.2

 Created by Sergey Balalaev on 23.09.22.
 Copyright (c) 2022-2025 ByteriX. All rights reserved.

 Using from build phase:
 ${SRCROOT}/Scripts/ImageLinter.swift
 */

//
//  SwiftGen.swift
//
//
//  Created by Sergey Balalaev on 18.04.2024.
//

import Foundation

extension String {

    static let snakeSeporators = "-_"

    func lowercasedFirstLetter() -> String {
        return prefix(1).lowercased() + dropFirst()
    }

    func uppercasedFirstLetter() -> String {
        return prefix(1).uppercased() + dropFirst()
    }
}


fileprivate extension Array where Self.Element == String {
    func swiftGenFolders() -> [Self.Element] {
        guard let last = last else {
            return self
        }
        var result: [Self.Element] = dropLast()
        result.append(last.lowercasedFirstLetter())
        return result
    }

    func swiftGenCamel() -> [Self.Element] {
        guard let first = first else {
            return self
        }
        var result: [Self.Element] = dropFirst().map { $0.uppercasedFirstLetter() }
        result.insert(first, at: 0)
        return result
    }
}

extension String {
    func swiftGenCamel() -> String {
        return self
            .trimmingCharacters(in: CharacterSet(charactersIn: Self.snakeSeporators))
            .split(whereSeparator: { char in
                Self.snakeSeporators.contains { $0 == char }
            })
            .map { String($0) }
            .swiftGenCamel()
            .joined(separator: "")
    }
}

extension String {
    func swiftGenKey() -> String {
        return self
            .split(separator: "/")
            .map { String($0).swiftGenCamel() }
            .swiftGenFolders()
            .joined(separator: ".")
    }
}
//
//  Settings+Keys.swift
//  Imagelinter
//
//  Created by Sergey Balalaev on 23.12.2025.
//

extension Settings {
    enum Key: String {
        case isEnabled
        case relativeImagesPaths
        case relativeImagesPath
        case relativeSourcePaths
        case relativeSourcePath

        case usingTypes
        case checkingNameTypes

        case ignoredUnusedImages
        case ignoredUndefinedImages

        case rastorExtensions
        case vectorExtensions

        case sourcesExtensions
        case resourcesExtensions

        case isAllFilesErrorShowing

        case maxVectorFileSize
        case maxVectorImageSize

        case maxRastorFileSize
        case maxRastorImageSize


        case isCheckingFileSize
        case isCheckingImageSize
        case isCheckingPdfVector
        case isCheckingSvgVector
        case isCheckingScaleSize
        case isCheckingDuplicatedByName
        case isCheckingDuplicatedByContent

        case targetPlatforms

        enum UsingType: String {
            case swiftUI
            case uiKit
            case uiKitLiteral
            case swiftGen
            case custom
        }

        enum CheckingNameType: String {
            case firstUpperCase
            case camelCase
            case sneak_case
            case kebab_case
            case custom

            func convert(message: String?, filter: ImageFilter?) -> Settings.CheckingNameType {
                if let message {
                    switch self {
                    case .firstUpperCase: return .firstUpperCase(message: message, filter: filter)
                        case .camelCase: return .camelCase(message: message, filter: filter)
                        case .sneak_case: return .sneak_case(message: message, filter: filter)
                        case .kebab_case: return .kebab_case(message: message, filter: filter)
                        case .custom: return .custom(pattern: "", message: message, filter: filter)
                    }
                } else {
                    switch self {
                        case .firstUpperCase: return .firstUpperCase(filter: filter)
                        case .camelCase: return .camelCase(filter: filter)
                        case .sneak_case: return .sneak_case(filter: filter)
                        case .kebab_case: return .kebab_case(filter: filter)
                        case .custom: return .custom(pattern: "", filter: filter)
                    }
                }
            }
        }

        enum TargetPlatform: String {
            case iOS
            case iPadOS
            case macOS
            case tvOS
            case visionOS
            case watchOS
        }
    }
}
//
//  Settings+Parse.swift
//  Imagelinter
//
//  Created by Sergey Balalaev on 23.12.2025.
//
import Foundation

extension Settings {

    mutating func load(from stringData: String) {
        let lines = stringData.components(separatedBy: .newlines)

        var currentKey: Key? = nil
        var isStartKey: Bool = false
        var lineIndex = 0

        while lineIndex < lines.count {
            let line = lines[lineIndex].trimmingCharacters(in: .whitespaces)
            lineIndex += 1

            if line.hasPrefix("#") {
                continue
            }

            var currentValue: String? = nil
            if let value = Self.getArrayValue(line: line) {
                currentValue = value
            } else if let object = Self.getObject(line: line) {
                if let key = Key(rawValue: object.name) {
                    currentKey = key
                    currentValue = object.value
                    isStartKey = true
                }
            }

            func getSize(defaultSize: CGSize) -> CGSize {
                var width = defaultSize.width
                var height = defaultSize.height

                while lineIndex < lines.count
                {
                    let line = lines[lineIndex].trimmingCharacters(in: .whitespaces)
                    if line.hasPrefix("#") == false,
                       let object = Self.getObject(line: line)
                    {
                        if object.name == "width" {
                            width = Double(object.value) ?? defaultSize.width
                        } else if object.name == "height" {
                            height = Double(object.value) ?? defaultSize.height
                        } else {
                            break
                        }
                    }
                    lineIndex += 1
                }

                return CGSize(width: width, height: height)
            }

            guard let currentKey else { continue }
            switch currentKey {
            case .isEnabled:
                if let value = currentValue, let isEnabled = Bool(value) {
                    self.isEnabled = isEnabled
                }
            case .relativeImagesPath, .relativeImagesPaths:
                if let value = currentValue, value != "" {
                    relativeImagesPaths.append(Self.pathWithSlash(value))
                }
            case .relativeSourcePath, .relativeSourcePaths:
                if let value = currentValue, value != "" {
                    relativeSourcePaths.append(Self.pathWithSlash(value))
                }
            case .usingTypes:
                if let value = currentValue, value.isEmpty == false {
                    if let object = Self.getObject(line: value), object.name == "case" {
                        if let usingType = Key.UsingType(rawValue: object.value) {
                            switch usingType {
                            case .swiftUI:
                                self.usingTypes.append(.swiftUI)
                            case .uiKit:
                                self.usingTypes.append(.uiKit)
                            case .uiKitLiteral:
                                self.usingTypes.append(.uiKitLiteral)
                            case .swiftGen:
                                guard lineIndex < lines.count else {
                                    break
                                }
                                let line = lines[lineIndex].trimmingCharacters(in: .whitespaces)
                                if line.hasPrefix("#") == false,
                                   let object = Self.getObject(line: line),
                                   object.name == "enumName"
                                {
                                    lineIndex += 1
                                    self.usingTypes.append(.swiftGen(enumName: object.value))
                                }
                            case .custom:
                                guard lineIndex < lines.count else {
                                    break
                                }
                                var line = lines[lineIndex].trimmingCharacters(in: .whitespaces)
                                var customPattern: String?
                                var customIsSwiftGen = false

                                // TODO: # needs just continue
                                while lineIndex < lines.count,
                                      line.hasPrefix("#") == false,
                                      let object = Self.getObject(line: line),
                                      object.name == "pattern" || object.name == "isSwiftGen"
                                {
                                    lineIndex += 1
                                    if object.name == "pattern" {
                                        customPattern = object.value
                                    } else if object.name == "isSwiftGen", let isSwiftGen = Bool(object.value) {
                                        customIsSwiftGen = isSwiftGen
                                    }
                                    if lineIndex < lines.count {
                                        line = lines[lineIndex].trimmingCharacters(in: .whitespaces)
                                    }
                                }
                                if let customPattern {
                                    self.usingTypes.append(.custom(pattern: customPattern, isSwiftGen: customIsSwiftGen))
                                }
                            }
                        }
                    }
                } else if isStartKey {
                    self.usingTypes = []
                }
            case .checkingNameTypes:
                // TODO: # needs refactory with delete CheckingNameRegexPattern
                if let value = currentValue, value.isEmpty == false {
                    if let object = Self.getObject(line: value), object.name == "case" {
                        if let checkingNameType = Key.CheckingNameType(rawValue: object.value) {
                            switch checkingNameType {
                            case .firstUpperCase, .camelCase, .sneak_case, .kebab_case:
                                var customMessage: String?
                                var customFilter: ImageFilter?
                                while lineIndex < lines.count {
                                    let line = lines[lineIndex].trimmingCharacters(in: .whitespaces)
                                    if line.hasPrefix("#") {
                                        lineIndex += 1
                                        continue
                                    }
                                    guard let object = Self.getObject(line: line),
                                          object.name == "message" || object.name == "filter" else {
                                        break
                                    }
                                    if object.name == "message" {
                                        customMessage = object.value
                                    } else if object.name == "filter" {
                                        customFilter = ImageFilter(object.value)
                                    }
                                    lineIndex += 1
                                }
                                self.checkingNameTypes.append(checkingNameType.convert(message: customMessage, filter: customFilter))
                            case .custom:
                                guard lineIndex < lines.count else {
                                    break
                                }
                                var line = lines[lineIndex].trimmingCharacters(in: .whitespaces)
                                var customPattern: String?
                                var customMessage: String?
                                var customFilter: ImageFilter?

                                // TODO: # needs just continue
                                while lineIndex < lines.count,
                                      line.hasPrefix("#") == false,
                                      let object = Self.getObject(line: line),
                                      object.name == "pattern" || object.name == "message" || object.name == "filter"
                                {
                                    lineIndex += 1
                                    if object.name == "pattern" {
                                        customPattern = object.value
                                    } else if object.name == "message" {
                                        customMessage = object.value
                                    } else if object.name == "filter" {
                                        customFilter = ImageFilter(object.value)
                                    }
                                    if lineIndex < lines.count {
                                        line = lines[lineIndex].trimmingCharacters(in: .whitespaces)
                                    }
                                }
                                if let customPattern {
                                    if let customMessage, customMessage.isEmpty == false {
                                        self.checkingNameTypes.append(.custom(pattern: customPattern, message: customMessage, filter: customFilter))
                                    } else {
                                        self.checkingNameTypes.append(.custom(pattern: customPattern, filter: customFilter))
                                    }
                                }
                            }
                        }
                    }
                } else if isStartKey {
                    self.checkingNameTypes = []
                }
            case .ignoredUnusedImages:
                if let value = currentValue, value.isEmpty == false {
                    self.ignoredUnusedImages.insert(value)
                } else if isStartKey {
                    self.ignoredUnusedImages = []
                }
            case .ignoredUndefinedImages:
                if let value = currentValue, value.isEmpty == false {
                    self.ignoredUndefinedImages.insert(value)
                } else if isStartKey {
                    self.ignoredUndefinedImages = []
                }
            case .rastorExtensions:
                if let value = currentValue, value.isEmpty == false {
                    self.rastorExtensions.insert(value.uppercased())
                } else if isStartKey {
                    self.rastorExtensions = []
                }
            case .vectorExtensions:
                if let value = currentValue, value.isEmpty == false {
                    self.vectorExtensions.insert(value.uppercased())
                } else if isStartKey {
                    self.vectorExtensions = []
                }
            case .sourcesExtensions:
                if let value = currentValue, value.isEmpty == false {
                    self.sourcesExtensions.insert(value.uppercased())
                } else if isStartKey {
                    self.sourcesExtensions = []
                }
            case .resourcesExtensions:
                if let value = currentValue, value.isEmpty == false {
                    self.resourcesExtensions.insert(value.uppercased())
                } else if isStartKey {
                    self.resourcesExtensions = []
                }
            case .isAllFilesErrorShowing:
                if let value = currentValue, let isAllFilesErrorShowing = Bool(value) {
                    self.isAllFilesErrorShowing = isAllFilesErrorShowing
                }
            case .maxVectorFileSize:
                if let value = currentValue, let maxVectorFileSize = UInt64(value) {
                    self.maxVectorFileSize = maxVectorFileSize
                }
            case .maxVectorImageSize:
                self.maxVectorImageSize = getSize(defaultSize: self.maxVectorImageSize)

            case .maxRastorFileSize:
                if let value = currentValue, let maxRastorFileSize = UInt64(value) {
                    self.maxRastorFileSize = maxRastorFileSize
                }
            case .maxRastorImageSize:
                self.maxRastorImageSize = getSize(defaultSize: self.maxRastorImageSize)

            case .isCheckingFileSize:
                if let value = currentValue, let isCheckingFileSize = Bool(value) {
                    self.isCheckingFileSize = isCheckingFileSize
                }
            case .isCheckingImageSize:
                if let value = currentValue, let isCheckingImageSize = Bool(value) {
                    self.isCheckingImageSize = isCheckingImageSize
                }
            case .isCheckingPdfVector:
                if let value = currentValue, let isCheckingPdfVector = Bool(value) {
                    self.isCheckingPdfVector = isCheckingPdfVector
                }
            case .isCheckingSvgVector:
                if let value = currentValue, let isCheckingSvgVector = Bool(value) {
                    self.isCheckingSvgVector = isCheckingSvgVector
                }
            case .isCheckingScaleSize:
                if let value = currentValue, let isCheckingScaleSize = Bool(value) {
                    self.isCheckingScaleSize = isCheckingScaleSize
                }
            case .isCheckingDuplicatedByName:
                if let value = currentValue, let isCheckingDuplicatedByName = Bool(value) {
                    self.isCheckingDuplicatedByName = isCheckingDuplicatedByName
                }
            case .isCheckingDuplicatedByContent:
                if let value = currentValue, let isCheckingDuplicatedByContent = Bool(value) {
                    self.isCheckingDuplicatedByContent = isCheckingDuplicatedByContent
                }
            case .targetPlatforms:
                if let value = currentValue, value.isEmpty == false {
                    if let targetPlatform = Key.TargetPlatform(rawValue: value) {
                        switch targetPlatform {
                        case .iOS:
                            self.targetPlatforms.append(.iOS)
                        case .iPadOS:
                            self.targetPlatforms.append(.iPadOS)
                        case .macOS:
                            self.targetPlatforms.append(.macOS)
                        case .tvOS:
                            self.targetPlatforms.append(.tvOS)
                        case .visionOS:
                            self.targetPlatforms.append(.visionOS)
                        case .watchOS:
                            self.targetPlatforms.append(.watchOS)
                        }
                    }
                } else if isStartKey {
                    self.targetPlatforms = []
                }
            }
            isStartKey = false
        }
    }

    private struct Object {
        let name: String
        let value: String
    }

    private static let regexObject = try! NSRegularExpression(pattern: #"^([A-z0-9]+?)\s*:"#, options: [.caseInsensitive])

    private static func getObject(line: String) -> Object? {
        let results = regexObject.matches(in: line, range: NSRange(line.startIndex..., in: line))
        if let result = results.first {
            let name = String(line[Range(result.range, in: line)!]).dropLast().trimmingCharacters(in: .whitespaces)
            let value = line.suffix(from: Range(result.range, in: line)!.upperBound).trimmingCharacters(in: .whitespaces)
            return Object(name: name, value: value)
        }
        return nil
    }

    private static func getArrayValue(line: String) -> String? {
        guard line.first == "-" else {
            return nil
        }
        return line.dropFirst().trimmingCharacters(in: .whitespaces)
    }

    private static func getArrayObject(line: String) -> Object? {
        guard let value = getArrayValue(line: line) else {
            return nil
        }
        return getObject(line: value)
    }

}
//
//  ImageInfo.swift
//  
//
//  Created by Sergey Balalaev on 03.04.2024.
//

import Foundation
import AppKit

struct AssetContents: Decodable {
    let images: [Image]
    struct Image: Decodable {
        let filename: String?
        let scale: String?
    }
}

struct FolderContents: Decodable {
    let properties: Properties?
    struct Properties: Decodable {
        let isNamespace: Bool

        enum CodingKeys: String, CodingKey {
            case isNamespace = "provides-namespace"
        }
    }
}

func load<T: Decodable>(_ type: T.Type, dir: String, for folder: String) -> T? {
    let contentsPath = dir + folder + "/Contents.json"
    guard let contentsData = NSData(contentsOfFile: contentsPath) as? Data else {
        return nil
    }
    return try? JSONDecoder().decode(type, from: contentsData)
}

let imagesetExtension = ".imageset"
let appIconExtension = ".appiconset"
let assetExtension = ".xcassets"

public class ImageInfo {
    struct File {
        // needs concatinate with ImageInfo.dir
        let path: String
        // if nil that vector-universal
        let scale: Int?

        init(path: String, scale: Int?) {
            self.path = path
            self.scale = scale
        }
    }

    public enum ImageType: String {
        case undefined
        case vector
        case rastor
        case mixed
    }

    let name: String
    // dir for current Asset
    let dir: String
    var files: [File]

    var hash: String = ""

    var type: ImageType = .undefined

    var fileSizes: [UInt64] = []
    private(set) var imageSizes: [(width: Int, height: Int)] = []

    private func setAndCheckType(newType: ImageType, filePath: String){
        if type != .undefined, newType != type {
            printError(
                filePath: filePath,
                message: "The image with name '\(name)' has different types of files: \(newType) and \(type)"
            )
            type = .mixed
        } else {
            type = newType
        }
    }

    private init(name: String, dir: String, path: String, scale: Int?) {
        self.name = name
        self.dir = dir
        files = [File(path: path, scale: scale)]
    }

    static func processFound(dir: String, path: String) -> ImageInfo? {
        var isAsset = false
        var folderName = ""
        let components = path.split(separator: "/")
        for (index, component) in components.enumerated() {
            if component.hasSuffix(assetExtension) {
                isAsset = true
            } else {
                if isAsset == false { // only for asset
                    continue
                }
                if component.hasSuffix(imagesetExtension) { // it is asset
                    let name = (component as NSString).substring(to: component.count - imagesetExtension.count)
                    if let contents = load(AssetContents.self, dir: dir, for: components[0..<index + 1].joined(separator: "/")) {
                        let fileName = (path as NSString).lastPathComponent
                        let scale: Int? = contents.images.reduce(into: nil) { result, image in
                            if image.filename == fileName {
                                result = image.scale?.scale
                            }
                        }
                        return processFound(name: folderName + name, dir: dir, path: path, scale: scale)
                    } else {
                        printError(filePath: path, message: "Not readed scale information. Found for image '\(name)'", isWarning: true)

                        return processFound(name: folderName + name, dir: dir, path: path, scale: nil)
                    }
                    //break
                } else if component.hasSuffix(appIconExtension) { // it is Application icon and we will ignore it
                    return nil
                } else {
                    // It is folder, but way???
                    if let contents = load(FolderContents.self, dir: dir, for: components[0..<index + 1].joined(separator: "/")) {
                        if contents.properties?.isNamespace ?? false {
                            folderName += component + "/"
                        }
                    }
                }
            }
        }
        if !isAsset {
            let name = nameOfImageFile(path: path)
            return processFound(name: name.path, dir: dir, path: path, scale: name.scale)
        }
        return nil
    }

    private static func processFound(name: String, dir: String, path: String, scale: Int?) -> ImageInfo {
        if let existImage = foundedImages[name] {
            existImage.files.append(File(path: path, scale: scale))
            return existImage
        } else {
            let result = ImageInfo(name: name, dir: dir, path: path, scale: scale)
            foundedImages[name] = result
            if isSwiftGen {
                foundedSwiftGenMirrorImages[name.swiftGenKey()] = name
            }
            return result
        }
    }

    private static func nameOfImageFile(path: String) -> (path: String, scale: Int) {
        return pathOfImageFile(path: (path as NSString).lastPathComponent)
    }

    private static func pathOfImageFile(path: String) -> (path: String, scale: Int) {
        var name = (path as NSString).deletingPathExtension
        var scale = 1
        for imageScale in allImageScales {
            let scaleSuffix = "@\(imageScale)x"
            if name.hasSuffix(scaleSuffix) {
                name = String(name.dropLast(scaleSuffix.count))
                scale = imageScale
                break
            }
        }
        return (name, scale)
    }

    private static func isTheSameImage(path1: String, path2: String) -> Bool {
        pathOfImageFile(path: path1).path == pathOfImageFile(path: path2).path
    }

    private var assetPath: String? {
        var result: String?
        for imageFile in files {
            let components = imageFile.path.split(separator: "/")
            if components.isEmpty { // it just image
                return nil
            } else {
                for component in components {
                    if component.hasSuffix(imagesetExtension) { // it is asset
                        var name = (imageFile.path as NSString).components(separatedBy: imagesetExtension).first ?? ""
                        name = name + imagesetExtension
                        if let result = result {
                            if name != result {
                                return nil
                            }
                        } else {
                            result = name
                        }
                    }
                }
            }
        }
        return result
    }

    func error(with message: String) {
        for file in files {
            let imageFilePath = dir + file.path
            printError(filePath: imageFilePath, message: message)
            guard settings.isAllFilesErrorShowing else {
                break
            }
        }
    }

    func checkDuplicateByName() {
        guard files.count > 1 else {
            return
        }
        if assetPath == nil {
            var isDifferentImages = false
            for file in files {
                if !Self.isTheSameImage(path1: files.first?.path ?? "", path2: file.path) {
                    isDifferentImages = true
                    break
                }
            }
            if isDifferentImages {
                error(with: "Duplicated image with name: '\(name)'")
            }
        }
    }

    private static let svgSearchWidthHeightRegex = try! NSRegularExpression(pattern: #"<svg.*width="(.*?)p?t?".*height="(.*?)p?t?".*>"#, options: [])
    private static let svgSearchHeightWidthRegex = try! NSRegularExpression(pattern: #"<svg.*height="(.*?)p?t?".*width="(.*?)p?t?".*>"#, options: [])

    func checkImageSizeAndDetectType() {
        var scaledSize: (width: Int, height: Int)?
        for file in files {
            let imageFilePath = dir + file.path
            if let image = NSImage(contentsOfFile: imageFilePath) {
                let pixelSize = image.pixelSize ?? NSSize()
                let size = image.size
                if pixelSize.height == 0, pixelSize.width == 0 {
                    if size.height != 0, size.width != 0 {
                        setAndCheckType(newType: .vector, filePath: imageFilePath)
                        // it's okey just vector image
                        // but can problems
                        if let scale = file.scale {
                            printError(
                                filePath: imageFilePath,
                                message: "It is vector image. But it has scale = \(scale). Found for image '\(name)'",
                                isWarning: true
                            )
                        }
                        imageSizes.append((width: Int(size.width), height: Int(size.height)))
                        if size.width > settings.maxVectorImageSize.width || size.height > settings.maxVectorImageSize.height {
                            printError(
                                filePath: imageFilePath,
                                message: "The vector image has very biggest image size (\(size.width), \(size.height)). Max image size for vector is (\(settings.maxVectorImageSize.width), \(settings.maxVectorImageSize.height)). Found for image '\(name)'"
                            )
                        }
                    } else {
                        printError(filePath: imageFilePath, message: "Image has zero size. Found for image '\(name)'", isWarning: true)
                    }
                } else {
                    if let scale = file.scale {
                        setAndCheckType(newType: .rastor, filePath: imageFilePath)
                        if Int(pixelSize.width) % scale != 0 || Int(pixelSize.height) % scale != 0 {
                            let newScaledSize: (width: Double, height: Double) = (Double(pixelSize.width) / Double(scale), Double(pixelSize.height) / Double(scale))
                            printError(
                                filePath: imageFilePath,
                                message: "Image has floating size from scaled images. Real size is \(pixelSize) and scale = \(scale). Please check the file, it must have integer size after apply this scale. But you actually have \(newScaledSize). Found for image '\(name)'."
                            )
                        } else {
                            let newScaledSize: (width: Int, height: Int) = (Int(pixelSize.width) / scale, Int(pixelSize.height) / scale)
                            if let scaledSize = scaledSize {
                                if scaledSize != newScaledSize {
                                    printError(
                                        filePath: imageFilePath,
                                        message: "Image has different size for scaled group. Real size is \(pixelSize) with scale = \(scale) but expected \(NSSize(width: scaledSize.0 * scale, height: scaledSize.1 * scale)). Found for image '\(name)'"
                                    )
                                }
                            } else {
                                scaledSize = newScaledSize
                            }
                            imageSizes.append(newScaledSize)
                            if CGFloat(newScaledSize.width) > settings.maxRastorImageSize.width || CGFloat(newScaledSize.height) > settings.maxRastorImageSize.height{
                                printError(
                                    filePath: imageFilePath,
                                    message: "The rastor image has very biggest image size (\(newScaledSize.width), \(newScaledSize.height)). Max image size for rastor is (\(settings.maxRastorImageSize.width), \(settings.maxRastorImageSize.height)). Found for image '\(name)'"
                                )
                            }
                        }
                    }
                }
            } else if imageFilePath.uppercased().hasSuffix("SVG") { // NSImage can not support SVG files. You can use only from Assets
                setAndCheckType(newType: .vector, filePath: imageFilePath)
                if let scale = file.scale {
                    printError(
                        filePath: imageFilePath,
                        message: "It is vector image. But it has scale = \(scale). Found for image '\(name)'",
                        isWarning: true
                    )
                }

                // Need parse SVG and extract width / height for checking
                // examples:
                // vector: <svg width="37pt" height="37pt" viewBox="0 0 37 37" >
                // rastor: <svg width="50" height="50" viewBox="636,559,50,50">
                if settings.isCheckingImageSize {
                    if let string = try? String(contentsOfFile: imageFilePath, encoding: .ascii) {
                        let range = NSRange(location: 0, length: string.count)

                        if let result = Self.svgSearchWidthHeightRegex.firstMatch(in: string, options: [], range: range) {
                            print("VALUE!!!")
                            let _ = (1...result.numberOfRanges - 1).map { index in
                                let value = (string as NSString).substring(with: result.range(at: index))
                                print("VALUE=\(value)")
                            }
                        }
                    } else {
                        printError(filePath: imageFilePath, message: "Can not parse SVG file. Found for image '\(name)'")
                    }
                }
            } else {
                printError(filePath: imageFilePath, message: "That is not image. Found for image '\(name)'", isWarning: true)
            }
        }
        if type == .vector, files.count > 1 {
            printError(
                filePath: files.first?.path ?? "",
                message: "The vector image with name '\(name)' has \(files.count) files",
                isWarning: true
            )
        } else if type == .rastor {
            // Analysis scales with dependency on target platforms
            let currentScalesDictionary : Dictionary<Int, File> = files.reduce(Dictionary<Int, File>()) { result, file in
                if let scale = file.scale {
                    var newResult = result
                    newResult[scale] = file
                    return newResult
                } else {
                    printError(
                        filePath: file.path,
                        message: "The rastor image with name '\(name)' has undefined scale. May be it's vector?",
                        isWarning: true
                    )
                }
                return result
            }
            let currentScales = Set<Int>(currentScalesDictionary.keys)
            let extraScales = currentScales.subtracting(targetScales)
            for extraScale in extraScales {
                printError(
                    filePath: currentScalesDictionary[extraScale]?.path ?? "",
                    message: "The rastor image with name '\(name)' has extra scale=\(extraScale) for current platforms target (\(settings.targetPlatforms)).",
                    isWarning: true
                )
            }
            let missingScales = targetScales.subtracting(currentScales)
            if missingScales.count > 0 {
                printError(
                    filePath: files.first?.path ?? "",
                    message: "The rastor image with name '\(name)' has missing scale=\(missingScales). You need add images with this scales for correct showing at selected target platforms = \(settings.targetPlatforms).",
                    isWarning: true
                )
            }
        }
    }

    func calculateData() -> Data? {
        var maxScale = 0
        var result: Data?
        for file in files {
            let imageFilePath = dir + file.path
            if let image = NSImage(contentsOfFile: imageFilePath), let pixelSize = image.pixelSize {
                let size = image.size
                if pixelSize.height == 0, pixelSize.width == 0 {
                    if size.height != 0, size.width != 0 {
                        // it's okey just vector image
                        var imageRect = CGRect(x: 0, y: 0, width: size.width, height: size.height)
                        let cgImage = image.cgImage(forProposedRect: &imageRect, context: nil, hints: nil)
                        if let data = cgImage?.png {
                            result = data
                            maxScale = 1
                        }
                    }
                } else {
                    if let scale = file.scale {
                        // calculate hash
                        if maxScale < scale {
                            var imageRect = CGRect(
                                x: 0,
                                y: 0,
                                width: Int(pixelSize.width) / scale,
                                height: Int(pixelSize.height) / scale
                            )
                            let cgImage = image.cgImage(forProposedRect: &imageRect, context: nil, hints: nil)
                            if let data = cgImage?.png {
                                result = data
                                maxScale = scale
                            }
                        }
                    }
                }
            }
        }
        return result
    }
}
//
//  Settings.swift
//  
//
//  Created by Sergey Balalaev on 02.04.2024.
//

import Foundation

public struct Settings {

    /// For enable or disable this script
    public internal(set) var isEnabled = true

    private(set) var dir: String = defaultDir

    /// Multipath  to folders with images you actually use in your project. For Example ["/YouProject/Resources/Images",  "/OtherProject"]
    public internal(set) var relativeImagesPaths: [String] = []

    /// Multipath  of the sources folders which will used in searching for images you actually use in your project. For Example ["/YouProject/Source",  "/OtherProject"]
    public internal(set) var relativeSourcePaths: [String] = []

    /// Using images type from code. If you use custom you need define regex pattern
    public enum UsingType {
        case swiftUI
        case uiKit
        case uiKitLiteral
        case swiftGen(enumName: String = "Asset")
        case custom(pattern: String, isSwiftGen: Bool)
    }

    /// you can use many types of images usage
    public internal(set) var usingTypes: [UsingType] = [
        .swiftGen(),
        .swiftUI,
        .uiKit,
        .uiKitLiteral
    ]

    /// Patterns of checking of the image name with filter
    public enum CheckingNameType {
        case firstUpperCase(message: String = "Name should start with uppercase", filter: ImageFilter?)
        case camelCase(message: String = "Camel case support only", filter: ImageFilter?)
        case sneak_case (message: String = "Sneak case support only", filter: ImageFilter?)
        case kebab_case (message: String = "Kebab case support only", filter: ImageFilter?)
        case custom (pattern: String, message: String = "Custom name checking", filter: ImageFilter?)
    }

    /// you can check image name with a set of patterns
    public internal(set) var checkingNameTypes: [CheckingNameType] = []

    /// If you want to exclude unused image from checking, you can define they this
    public internal(set) var ignoredUnusedImages: Set<String> = [ ]
    public internal(set) var ignoredUndefinedImages: Set<String> = [ ]

    public internal(set) var rastorExtensions = Set<String>(["png", "jpg", "jpeg"].map{$0.uppercased()})
    public internal(set) var vectorExtensions = Set<String>(["pdf", "svg"].map{$0.uppercased()})

    public internal(set) var sourcesExtensions = Set<String>(["swift", "mm", "m"].map{$0.uppercased()})
    public internal(set) var resourcesExtensions = Set<String>(["storyboard", "xib"].map{$0.uppercased()})

    // If you wan't show double errors/warnings for all files of an image change this to false
    public internal(set) var isAllFilesErrorShowing = false

    // Maximum size of Vector files in bytes.
    public internal(set) var maxVectorFileSize: UInt64 = 20_000
    // Maximum size of Vector images in pixels.
    public internal(set) var maxVectorImageSize: CGSize = CGSize(width: 100, height: 100)

    // Maximum size of Rastor files in bytes.
    public internal(set) var maxRastorFileSize: UInt64 = 200_000
    // Maximum size of Rastor images in pixels.
    public internal(set) var maxRastorImageSize: CGSize = CGSize(width: 1000, height: 1000)

    public internal(set) var isCheckingFileSize = true
    public internal(set) var isCheckingImageSize = true

    public internal(set) var isCheckingPdfVector = true
    public internal(set) var isCheckingSvgVector = true
    public internal(set) var isCheckingScaleSize = true
    public internal(set) var isCheckingDuplicatedByName = true
    public internal(set) var isCheckingDuplicatedByContent = true

    /// Your project should compile for one or more platform. This need for detect quality of images.
    public enum TargetPlatform {
        case iOS
        case iPadOS
        case macOS
        case tvOS
        case visionOS
        case watchOS
    }

    /// yuo can use many platforms
    public internal(set) var targetPlatforms: [TargetPlatform] = [.iOS]

    init(){
        load()
    }

    public init(_ string: String) {
        load(from: string)
    }

}

extension Settings {

    private static let extensions = ["yml", "yaml"]
    private static let fileName = "imagelinter"
    private static let defaultDir: String = pathWithSlash(FileManager.default.currentDirectoryPath)

    static func pathWithSlash(_ path: String) -> String {
        var result = path
        if !result.hasSuffix("/") {
            result = result + "/"
        }
        return result
    }

    fileprivate mutating func load() {
        var dirs = [Self.defaultDir]

        var argIndex = 1
        while argIndex < CommandLine.arguments.count {
            if CommandLine.arguments[argIndex] == "--settingsPath" {
                argIndex += 1
                if argIndex < CommandLine.arguments.count {
                    dirs.append(CommandLine.arguments[argIndex])
                }
            }
            argIndex += 1
        }
        for dir in dirs {
            for ext in Self.extensions {
                load(dir: dir, ext: ext)
            }
        }
    }

    fileprivate mutating func load(dir: String, ext: String) {

        let filePath = (dir as NSString).appendingPathComponent(Self.fileName + "." + ext)
        guard let stringData = try? String(contentsOfFile: filePath, encoding: .utf8) else {
            print("Settings file '\(filePath)' not found")
            return
        }
        self.dir = dir
        print("Parse settings file '\(filePath)':")

        load(from: stringData)
    }
}

extension Settings.UsingType: Equatable {
    public static func == (lhs: Self, rhs: Self) -> Bool {
        switch (lhs, rhs) {
        case (.custom(pattern: let lhsPattern, isSwiftGen: let lhsIsSwiftGen), .custom(pattern: let rhsPattern, isSwiftGen: let rhsIsSwiftGen)):
            return (lhsPattern == rhsPattern) && (lhsIsSwiftGen == rhsIsSwiftGen)
        case (.swiftGen(enumName: let lhsEnumName), .swiftGen(enumName: let rhsEnumName)):
            return lhsEnumName == rhsEnumName
        case (.uiKitLiteral, .uiKitLiteral), (.uiKit, .uiKit), (.swiftUI, .swiftUI):
            return true
        default :
            return false
        }
    }
}
//
//  main.swift
//
//
//  Created by Sergey Balalaev on 02.04.2024.
//

import Foundation
import AppKit

// MARK: begin of settings the script

let settings = Settings()

// MARK: end of settings the script

let startDate = Date()

let imageSetExtensions = settings.rastorExtensions.union(settings.vectorExtensions)

struct RegexPattern {
    let pattern: NSRegularExpression
    let isSwiftGen: Bool
}
var sourcesRegex: [RegexPattern] = []
var isSwiftGen = false

private func addSourceRegexPattern(pattern: String, isSwiftGen: Bool) {
    guard let regex = try? NSRegularExpression(pattern: pattern, options: []) else {
        printError(filePath: #file, message: "Not right pattern for regex: \(pattern)", line: #line)
        return
    }
    sourcesRegex.append(RegexPattern(pattern: regex, isSwiftGen: isSwiftGen))
}

for usingType in settings.usingTypes {
    switch usingType {
    case .custom(let pattern, let isLocalSwiftGen):
        addSourceRegexPattern(pattern: pattern, isSwiftGen: isLocalSwiftGen)
        if isLocalSwiftGen {
            isSwiftGen = true
        }
    case .swiftUI:
        addSourceRegexPattern(pattern: #"\bImage\(\s*"(.*)"\s*\)"#, isSwiftGen: false)
    case .uiKit:
        addSourceRegexPattern(pattern: #"\bUIImage\(\s*named:\s*"(.*)"\s*\)"#, isSwiftGen: false)
    case .uiKitLiteral:
        addSourceRegexPattern(pattern: ##"\#imageLiteral\(\s*resourceName:\s*"(.*)"\s*\)"##, isSwiftGen: false)
    case .swiftGen(let enumName):
        addSourceRegexPattern(pattern: enumName +
                #"\s*\.((?:\.*[A-Z]{1}[A-z0-9]*)*)\s*((?:\.*[a-z]{1}[A-z0-9]*))(?:\s*\.image|\s*\.uiImage|\s*\.name)"#, isSwiftGen: true)
        isSwiftGen = true
    }
}

struct CheckingNameRegexPattern {
    let pattern: NSRegularExpression
    let message: String
    let filter: ImageFilter?
}
var checkingNameTypesRegex: [CheckingNameRegexPattern] = []

private func addCheckingNameRegexPattern(pattern: String, message: String, filter: ImageFilter?) {
    guard let regex = try? NSRegularExpression(pattern: pattern, options: []) else {
        printError(filePath: #file, message: "Not right pattern for regex: \(pattern)", line: #line)
        return
    }
    checkingNameTypesRegex.append(CheckingNameRegexPattern(pattern: regex, message: message, filter: filter))
}

for checkingNameType in settings.checkingNameTypes {
    switch checkingNameType {
    case .firstUpperCase(let message, let filter):
        addCheckingNameRegexPattern(pattern: #"^[A-Z].*$"#, message: message, filter: filter)
    case .camelCase(let message, let filter):
        addCheckingNameRegexPattern(pattern: #"^[a-zA-Z][a-zA-Z0-9\/]*$"#, message: message, filter: filter)
    case .sneak_case(let message, let filter):
        addCheckingNameRegexPattern(pattern: #"^[a-zA-Z][a-z0-9_\/]*$"#, message: message, filter: filter)
    case .kebab_case(let message, let filter):
        addCheckingNameRegexPattern(pattern: #"^[a-zA-Z][a-z0-9\-\/]*$"#, message: message, filter: filter)
    case .custom(let pattern, let message, let filter):
        addCheckingNameRegexPattern(pattern: pattern, message: message, filter: filter)
    }
}

print("checkingNameTypesRegex: \(checkingNameTypesRegex)")

let allImageScales = (1...3)
var targetScales: Set<Int> = []
for targetPlatform in settings.targetPlatforms {
    switch targetPlatform {
    case .iPadOS, .visionOS, .watchOS:
        targetScales.insert(2)
    case .iOS:
        targetScales.insert(2)
        targetScales.insert(3)
    case .macOS, .tvOS:
        targetScales.insert(1)
        targetScales.insert(2)
    }
}
if targetScales.count < 1 {
    print("\(CommandLine.arguments[0]):\(#line): error: targetPlatforms should have one or more values. It need for detect quality of images.")
}

// MARK: detection resources of images



var warningsCount = 0
var errorsCount = 0

// MARK: start analyze

if settings.isEnabled == false {
    print("\(CommandLine.arguments[0]):\(#line): warning: images checking cancelled")
    exit(000)
}

func printError(filePath: String, message: String,
                line: Int? = nil, isWarning: Bool = false) {
    var result = filePath
    if let line = line {
        result += ":\(line): "
    } else {
        result += ": "
    }
    result += isWarning ? "warning: " : "error: "
    print(result + message)
    if isWarning {
        warningsCount += 1
    } else {
        errorsCount += 1
    }
}

extension String {
    var linesCount: Int {
        return reduce(into: 1) { count, letter in
            if letter == "\n" { // This treats CRLF as one "letter", contrary to UnicodeScalars
                count += 1
            }
        }
    }

    var scale: Int? {
        guard (self as NSString).contains("x") else {
            return nil
        }
        return Int(dropLast(1))
    }
}

extension NSImage {
    var pixelSize: NSSize? {
        if let rep = representations.first {
            let size = NSSize(width: rep.pixelsWide, height: rep.pixelsHigh)
            return size
        }
        return nil
    }
}

extension CGImage {
    var png: Data? {
        guard let mutableData = CFDataCreateMutable(nil, 0),
              let destination = CGImageDestinationCreateWithData(mutableData, "public.png" as CFString, 1, nil) else { return nil }
        CGImageDestinationAddImage(destination, self, nil)
        guard CGImageDestinationFinalize(destination) else { return nil }
        return mutableData as Data
    }
}

func fileSize(fromPath path: String) -> UInt64 {
    let size: Any? = try? FileManager.default.attributesOfItem(atPath: path)[FileAttributeKey.size]
    guard let fileSize = size as? UInt64 else {
        printError(filePath: path, message: "Not read file size")
        return 0
    }
    return fileSize
}

func covertToString(fileSize: UInt64) -> String {
    ByteCountFormatter().string(fromByteCount: Int64(fileSize))
}

let pdfRasterPattern = #".*\/[Ii]mage.*"#
let pdfRasterRegex = try? NSRegularExpression(pattern: pdfRasterPattern, options: [])
let svgRasterPattern = #".*<image .*"#
let svgRasterRegex = try? NSRegularExpression(pattern: svgRasterPattern, options: [])

var foundedImages: [String: ImageInfo] = [:]
var foundedSwiftGenMirrorImages: [String: String] = [:]

print("image folders: \(settings.relativeImagesPaths)")

for relativeImagesPath in settings.relativeImagesPaths {
    let imagesPath = settings.dir + relativeImagesPath
    let imageFileEnumerator = FileManager.default.enumerator(atPath: imagesPath)

    while let imageFileName = imageFileEnumerator?.nextObject() as? String {
        let fileExtension = (imageFileName as NSString).pathExtension.uppercased()
        let imageFilePath = imagesPath + imageFileName
        if imageSetExtensions.contains(fileExtension) {

            if let imageInfo = ImageInfo.processFound(dir: imagesPath, path: imageFileName){

                let fileSize = fileSize(fromPath: imageFilePath)

                // TODO:  # bad idea fileSizes needs incapsulate to ImageInfo
                imageInfo.fileSizes.append(fileSize)

                if settings.vectorExtensions.contains(fileExtension) {
                    if settings.isCheckingFileSize, fileSize > settings.maxVectorFileSize {
                        printError(
                            filePath: imageFilePath,
                            message: "File size (\(covertToString(fileSize: fileSize))) of the image is very biggest. Max file size is \(covertToString(fileSize: settings.maxVectorFileSize)). Found for image '\(imageInfo.name)'"
                        )
                    }

                    if settings.isCheckingPdfVector || settings.isCheckingSvgVector {
                        if !FileManager.default.isReadableFile(atPath: imageFilePath) {
                            printError(filePath: imageFilePath, message: "Can not read file with path: '\(imageFilePath)'")
                        } else {
                            do {
                                let string = try String(contentsOfFile: imageFilePath, encoding: .isoLatin1)

                                let range = NSRange(location: 0, length: string.count)
                                if settings.isCheckingPdfVector, pdfRasterRegex?.firstMatch(in: string, options: [], range: range) != nil {
                                    printError(filePath: imageFilePath, message: "PDF File is not a pure vector. Found for image '\(imageInfo.name)'")
                                }
                                if settings.isCheckingSvgVector, svgRasterRegex?.firstMatch(in: string, options: [], range: range) != nil {
                                    printError(filePath: imageFilePath, message: "SVG File is not a pure vector. Found for image '\(imageInfo.name)'")
                                }
                            } catch let error {
                                printError(filePath: imageFilePath, message: "Can not parse Vector file. Found for image '\(imageInfo.name)' with error: `\(error.localizedDescription)`")
                            }
                        }
                    }
                } else if settings.rastorExtensions.contains(fileExtension) {
                    if settings.isCheckingFileSize, fileSize > settings.maxRastorFileSize {
                        printError(
                            filePath: imageFilePath,
                            message: "File size (\(covertToString(fileSize: fileSize))) of the image is very biggest. Max file size is \(covertToString(fileSize: settings.maxRastorFileSize)). Found for image '\(imageInfo.name)'"
                        )
                    }
                }
            }
        } else if imageFileName.hasSuffix(imagesetExtension) {
            let fileEnumerator = FileManager.default.enumerator(atPath: imageFilePath)
            var files: Set<String> = []
            while let fileName = fileEnumerator?.nextObject() as? String {
                files.insert(fileName)
            }
            let name = ((imageFileName as NSString).lastPathComponent as NSString).deletingPathExtension
            if let content = load(AssetContents.self, dir: imagesPath, for: imageFileName) {
                let contentFileNames = Set<String>(content.images.compactMap { $0.filename })
                if contentFileNames.isEmpty {
                    printError(filePath: imageFileName, message: "Empty asset with name '\(name)'")
                }
                let notFoundFile = contentFileNames.subtracting(files)
                for file in notFoundFile {
                    printError(filePath: imageFileName, message: "Not found file '\(file)' for Asset with name '\(name)'")
                }
            } else {
                printError(filePath: imageFileName, message: "Empty folder for Asset with name '\(name)'")
            }
        }
    }
}

// MARK: - detect unused Images


var usedImages: [String] = []
var usedImagesFromSwiftGen: [String] = []
let resourcesRegex = try! NSRegularExpression(pattern: #"<\bimage name="(.[A-z0-9]*)""#, options: [])

print("source folders: \(settings.relativeSourcePaths)")
for relativeSourcePath in settings.relativeSourcePaths {
    let sourcePath = settings.dir + relativeSourcePath
    print("source path: \(sourcePath)")
    // Search all using
    let sourceFileEnumerator = FileManager.default.enumerator(atPath: sourcePath)
    while let sourceFileName = sourceFileEnumerator?.nextObject() as? String {
        let fileExtension = (sourceFileName as NSString).pathExtension.uppercased()
        let filePath = sourcePath + sourceFileName
        // checks the extension to source
        if settings.sourcesExtensions.contains(fileExtension) {
            if let string = try? String(contentsOfFile: filePath, encoding: .utf8) {
                let range = NSRange(location: 0, length: (string as NSString).length)
                sourcesRegex.forEach{ regex in
                    regex.pattern.enumerateMatches(
                        in: string,
                        options: [],
                        range: range) { result, _, _ in
                            addUsedImage(from: string, result: result, path: filePath, isSwiftGen: regex.isSwiftGen)
                        }
                }
            }
        } else if settings.resourcesExtensions.contains(fileExtension) { // checks the extension to resource
            if let string = try? String(contentsOfFile: filePath, encoding: .utf8) {
                let range = NSRange(location: 0, length: (string as NSString).length)
                resourcesRegex.enumerateMatches(in: string,
                                                options: [],
                                                range: range) { result, _, _ in
                    addUsedImage(from: string, result: result, path: filePath)
                }
            }
        }
    }
}

func addUsedImage(from string: String, result: NSTextCheckingResult?, path: String, isSwiftGen: Bool = false) {
    guard let result = result, result.numberOfRanges > 0 else {
        return
    }
    // first range is matching, all next is groups
    let value = (1...result.numberOfRanges - 1).map { index in
        (string as NSString).substring(with: result.range(at: index))
    }.joined()
    var foundedImage: Any? = nil
    if isSwiftGen {
        usedImagesFromSwiftGen.append(value)
        foundedImage = foundedSwiftGenMirrorImages[value]
    } else {
        usedImages.append(value)
        foundedImage = foundedImages[value]
    }

    if foundedImage == nil, settings.ignoredUndefinedImages.contains(value) == false {
        let line = (string as NSString).substring(with: NSRange(location: 0, length: result.range(at: 0).location)).linesCount

        printError(filePath: path, message: "Not found image with name '\(value)'", line: line)
    }
}

let standartUnusedImages = Set(foundedImages.keys).subtracting(usedImages).subtracting(settings.ignoredUnusedImages)
let swiftGenUnusedImages = Set(foundedSwiftGenMirrorImages.keys).subtracting(usedImagesFromSwiftGen).subtracting(settings.ignoredUnusedImages)
let unusedImages = isSwiftGen ? Set(standartUnusedImages).intersection(swiftGenUnusedImages.compactMap {foundedSwiftGenMirrorImages[$0]} ) : standartUnusedImages

for unusedImage in unusedImages {
    if let imageInfo = foundedImages[unusedImage] {
        imageInfo.error(with: "File unused from code. Found for image '\(imageInfo.name)'")
    }
}

let images: [ImageInfo] = foundedImages.values.map { $0 }
for imageInfo in images {
    if settings.isCheckingDuplicatedByName {
        imageInfo.checkDuplicateByName()
    }
    if settings.isCheckingScaleSize {
        imageInfo.checkImageSizeAndDetectType()
    }
    if settings.isCheckingDuplicatedByContent {
        if let data = imageInfo.calculateData() {
            imageInfo.hash = "\(data.count)"
        }
    }
}

for imageName in Set(foundedImages.keys).subtracting(settings.ignoredUnusedImages) {
    guard let imageInfo = foundedImages[imageName] else {
        continue
    }
    var message = ""
    for checkingNameTypeRegex in checkingNameTypesRegex {
        if let filter = checkingNameTypeRegex.filter {
            if !filter.include(image: imageInfo) {
                continue
            }
        }
        if checkingNameTypeRegex.pattern.firstMatch(in: imageName, options: [], range: NSRange(location: 0, length: imageName.count)) == nil {
            message += checkingNameTypeRegex.message + ". "
        }
    }
    if message != "" {
        imageInfo.error(with: "Incorrect image name '\(imageInfo.name)': \(message)")
    }
}

if settings.isCheckingDuplicatedByContent {
    for (index, imageInfo1) in images.enumerated() {
        for i in index + 1..<images.count {
            let imageInfo2 = images[i]
            if imageInfo1.hash.isEmpty == false, imageInfo1.hash == imageInfo2.hash,
               imageInfo1.calculateData() == imageInfo2.calculateData() {
                let file1 = imageInfo1.files.first!
                let imageFilePath1 = imageInfo1.dir + file1.path
                let file2 = imageInfo2.files.first!
                let imageFilePath2 = imageInfo2.dir + file2.path
                printError(filePath: imageFilePath1, message: "image '\(imageInfo1.name)' duplicate by content '\(imageInfo2.name)' with path '\(imageFilePath2)'")
            }
        }
    }
}

print("Number of images: \(foundedImages.values.reduce(into: 0) { $0 += $1.files.count })")
print("Number of warnings: \(warningsCount)")
print("Number of errors: \(errorsCount)")
print("Time: \(Date().timeIntervalSince(startDate)) sec.")

if errorsCount > 0 {
    exit(1)
}
//
//  ImageFilter.swift
//  Imagelinter
//
//  Created by Sergey Balalaev on 09.12.2025.
//

import Foundation

public struct ImageFilter {

    public protocol Condition {
        func include(image: ImageInfo) -> Bool
    }

    public private(set) var andConditions: [Condition] = []

    public init? (_ string: String) {
        guard string.isEmpty == false else {
            return nil
        }
        string.components(separatedBy: ",").forEach { conditionString in
            if let orConditions = OrCondition(conditionString) {
                andConditions.append(orConditions)
            }
        }
        if andConditions.isEmpty {
            return nil
        }
    }

    public func include(image: ImageInfo) -> Bool {
        var result = true
        andConditions.forEach { condition in
            result = result && condition.include(image: image)
        }
        return result
    }
}

extension ImageFilter {
    public struct OrCondition: Condition {
        public private(set) var orConditions: [Condition] = []

        init? (_ string: String) {
            guard string.isEmpty == false else {
                return nil
            }
            if let imageTypeCondition = ImageTypeCondition(string) {
                orConditions.append(imageTypeCondition)
            }
            if let sizeCondition = SizeCondition(string) {
                orConditions.append(sizeCondition)
            }
            if orConditions.isEmpty {
                return nil
            }
        }

        public func include(image: ImageInfo) -> Bool {
            var result: Bool = false
            orConditions.forEach { condition in
                result = result || condition.include(image: image)
            }
            return result
        }
    }
}

extension ImageFilter {
    public struct ImageTypeCondition: Condition {

        private static let pattern = try! NSRegularExpression(pattern: #"[\s\/\|\/]*(undefined|rastor|vector|mixed)[\s\/\|\/]*"#, options: [])

        public private(set) var types: Set<ImageInfo.ImageType>

        init? (_ string: String) {
            guard string.isEmpty == false else {
                return nil
            }
            var types = Set<ImageInfo.ImageType>()
            Self.pattern.matches(in: string, options: [], range: NSRange(string.startIndex..., in: string)).forEach
            { result in
                guard result.numberOfRanges > 0 else {
                    return
                }
                (1...result.numberOfRanges - 1).map { index in
                    let value = (string as NSString).substring(with: result.range(at: index))
                    if let type = ImageInfo.ImageType(rawValue: value) {
                        types.insert(type)
                    }
                }
            }
            if types.isEmpty {
                return nil
            }
            self.types = types
        }

        public func include(image: ImageInfo) -> Bool {
            types.contains(image.type)
        }
    }
}

extension ImageFilter {
    public enum Messure {
        case bytes
        case pixels

        init?(string: String) {
            if string == "PX" || string == "px" || string == "Px" {
                self = .pixels
            } else if string == "B" || string == "b" {
                self = .bytes
            } else {
                return nil
            }
        }
    }

    public enum Comparison {
        case equal
        case greater
        case less

        init?(string: String) {
            if string == ">" || string == "=>" || string == ">=" {
                self = .greater
            } else if string == "<" || string == "=<" || string == "<=" {
                self = .less
            } else if string == "=" || string == "==" {
                self = .equal
            } else {
                return nil
            }
        }
    }

    public struct Size {
        public let value: Int64
        public let messure: Messure
        public let comparison: Comparison

        init?(strings: [String]) {
            guard strings.count == 4 else {
                return nil
            }
            guard let comparison = Comparison(string: strings[0]) else {
                return nil
            }
            guard var rawValue = Double(strings[1]) else {
                return nil
            }
            guard let messure = Messure(string: strings[3]) else {
                return nil
            }
            let scale = strings[2].uppercased()
            if messure == .pixels {
                if scale == "M" {
                    rawValue *= 1000 * 1000
                } else if scale == "K" {
                    rawValue *= 1000
                }
            } else if messure == .bytes {
                if scale == "M" {
                    rawValue *= 1024 * 1024
                } else if scale == "K" {
                    rawValue *= 1024
                }
            }
            self.value = Int64(rawValue)
            self.messure = messure
            self.comparison = comparison
        }

        public func include(image: ImageInfo) -> Bool {
            var value: UInt64 = 0

            switch messure {
            case .bytes:
                guard let size = image.fileSizes.first else {
                    return true
                }

                value = size
                for item in image.fileSizes {
                    if value < item {
                        value = item
                    }
                }
            case .pixels:
                guard let size = image.imageSizes.first else {
                    return true
                }

                value = UInt64(size.width)
                for item in image.imageSizes {
                    if value < UInt64(item.height) {
                        value = UInt64(item.height)
                    } else if value < UInt64(item.width) {
                        value = UInt64(item.width)
                    }
                }
            }

            switch comparison {
            case .equal:
                return value == Int64(self.value)
            case .greater:
                return value >= Int64(self.value)
            case .less:
                return value <= Int64(self.value)
            }
        }
    }

    public struct SizeCondition: Condition {
        private static let pattern = try! NSRegularExpression(pattern: #"[\s\/\|\/]*(>|=>|>=|<|=<|<=|=|==)\s*([0-9.]*)\s*(M|m|K|k|)(PX|px|Px|b|B)[\s\/\|\/]*"#, options: [])

        public private(set) var size: [Size] = []

        init? (_ string: String) {
            guard string.isEmpty == false else {
                return nil
            }
            Self.pattern.matches(in: string, options: [], range: NSRange(string.startIndex..., in: string)).forEach
            { result in
                guard result.numberOfRanges > 0 else {
                    return
                }
                var strings : [String] = []
                (1...result.numberOfRanges - 1).map { index in
                    let value = (string as NSString).substring(with: result.range(at: index))
                    strings.append(value)
                }
                if let size = Size(strings: strings) {
                    self.size.append(size)
                }
            }
            if self.size.isEmpty {
                return nil
            }
        }

        public func include(image: ImageInfo) -> Bool {
            var result: Bool = false

            for item in size {
                result = result || item.include(image: image)
            }

            return result
        }
    }
}