1499 lines
64 KiB
Swift
1499 lines
64 KiB
Swift
import SwiftUI
|
||
import VisionKit
|
||
import Vision
|
||
import LabWiseKit
|
||
import FoundationModels
|
||
|
||
// MARK: - On-device AI label extraction
|
||
|
||
@Generable
|
||
struct LabelExtraction {
|
||
@Guide(description: "The product or chemical name as it appears on the label, e.g. 'Neutralization/Binding Buffer (S3)' or 'Sodium Chloride'. Empty string if not found.")
|
||
var chemicalName: String
|
||
@Guide(description: "Physical state: 'Solid', 'Liquid', or 'Gas'. Infer from context clues like 'solution', 'buffer', 'powder', 'crystals'. Empty string if unknown.")
|
||
var physicalState: String
|
||
@Guide(description: "Vendor or manufacturer name, e.g. 'Sigma-Aldrich', 'Fisher Scientific'. Empty string if not found.")
|
||
var vendor: String
|
||
@Guide(description: "CAS registry number in the format XXXXXXX-XX-X, e.g. '7647-14-5'. Empty string if not found.")
|
||
var casNumber: String
|
||
@Guide(description: "Lot number or batch number, e.g. 'SLBH4570V', '123456'. Usually preceded by 'Lot', 'Lot#', or 'Batch'. Empty string if not found.")
|
||
var lotNumber: String
|
||
@Guide(description: "Expiration or use-by date found explicitly in the label text. Normalize to YYYY-MM-DD if possible, otherwise return as-is. Return empty string if no expiration keyword and date are present in the text — do not guess.")
|
||
var expirationDate: String
|
||
@Guide(description: "The amount or quantity of contents, as a number only, e.g. '5', '100', '2.5'. Empty string if not found.")
|
||
var amount: String
|
||
@Guide(description: "The unit for the amount, e.g. 'g', 'mL', 'kg', 'mg', 'L'. Empty string if not found.")
|
||
var unit: String
|
||
@Guide(description: "Catalog or product number, e.g. 'P0662-500G', 'S7653'. Empty string if not found.")
|
||
var catalogNumber: String
|
||
@Guide(description: "Your confidence in the chemical name extraction, from 0 to 100. Use 90+ only when the name is explicitly printed as a clear product/chemical name. Use 50-89 when inferred. Use below 50 if the text is ambiguous or noisy.", .range(0...100))
|
||
var nameConfidence: Int
|
||
}
|
||
|
||
private let labelExtractionInstructions = Instructions {
|
||
"""
|
||
You are a laboratory chemical label parser. Given raw OCR text lines from a reagent bottle label, \
|
||
extract only the fields that are explicitly present in the text. \
|
||
Do NOT invent, infer, or hallucinate values — if a field is not clearly visible in the provided text, return an empty string for it. \
|
||
For expiration dates: look for keywords like EXP, EXPIRY, EXPIRATION, USE BY, BEST BEFORE followed by a date. \
|
||
For amount and unit: look for a number directly followed by a unit like g, gm, mg, kg, mL, L, mol. \
|
||
Set nameConfidence honestly: 90+ only when the product name is explicitly and clearly printed; 50-89 when inferred; below 50 when guessing.
|
||
"""
|
||
}
|
||
|
||
private let aiNameConfidenceThreshold = 60 // minimum confidence to apply AI-extracted name
|
||
|
||
// MARK: - Name arbitration
|
||
|
||
@Generable(description: "Result of comparing a chemical's IUPAC/systematic name against its label name")
|
||
struct NameArbitration {
|
||
@Guide(description: "True if the labelName is a common name, abbreviation, or trade name that refers to the same compound as iupacName. False if they seem unrelated.")
|
||
var isSameCompound: Bool
|
||
@Guide(description: "True if labelName is a common/abbreviated name and iupacName is the corresponding systematic/IUPAC name for it. False if labelName is also a systematic or verbose name.")
|
||
var labelIsCommonName: Bool
|
||
@Guide(description: "The name to display: if labelIsCommonName is true use the labelName, otherwise use the iupacName.")
|
||
var preferredName: String
|
||
}
|
||
|
||
private let nameArbitrationInstructions = Instructions {
|
||
"""
|
||
You are a chemistry expert. You will be given two names for a chemical compound: \
|
||
an IUPAC/systematic name from a database, and a name read from a product label. \
|
||
Determine if they refer to the same compound, and whether the label name is a \
|
||
common name or abbreviation (like 'CHAPS', 'HEPES', 'SDS', 'Ethanol') versus a \
|
||
systematic/verbose name. Prefer the common name when it is clearly an established \
|
||
abbreviation or trade name used in laboratory settings.
|
||
"""
|
||
}
|
||
|
||
@available(iOS 18.1, *)
|
||
private func arbitrateNames(iupacName: String, labelName: String) async -> NameArbitration? {
|
||
let model = SystemLanguageModel.default
|
||
guard case .available = model.availability else { return nil }
|
||
let session = LanguageModelSession(instructions: nameArbitrationInstructions)
|
||
let prompt = "IUPAC name: \(iupacName)\nLabel name: \(labelName)"
|
||
return try? await session.respond(to: prompt, generating: NameArbitration.self).content
|
||
}
|
||
|
||
/// Strings the model emits when it has nothing real to return.
|
||
private let aiNullishValues: Set<String> = [
|
||
"", "n/a", "na", "none", "null", "unknown", "not found", "not available",
|
||
"not specified", "not present", "not visible", "not stated", "not given",
|
||
"missing", "empty", "-", "—", "?", ".", "0", "00", "000"
|
||
]
|
||
|
||
/// Returns nil if the string is a model-generated placeholder rather than real data.
|
||
private func aiSanitize(_ value: String) -> String {
|
||
let lowered = value.trimmingCharacters(in: .whitespaces).lowercased()
|
||
if aiNullishValues.contains(lowered) { return "" }
|
||
return value.trimmingCharacters(in: .whitespaces)
|
||
}
|
||
|
||
/// Validates and sanitizes a date string. Returns empty string if it doesn't
|
||
/// look like a real date (e.g. "0000-00-00", "1900-01-01", "9999-99-99").
|
||
private func aiSanitizeDate(_ value: String) -> String {
|
||
let s = aiSanitize(value)
|
||
guard !s.isEmpty else { return "" }
|
||
// Reject zero/placeholder dates
|
||
let stripped = s.replacingOccurrences(of: "-", with: "")
|
||
.replacingOccurrences(of: "/", with: "")
|
||
.replacingOccurrences(of: "0", with: "")
|
||
if stripped.isEmpty { return "" } // all zeros after stripping separators
|
||
// Must contain a plausible 4-digit year (1900–2099)
|
||
let yearRegex = try? NSRegularExpression(pattern: #"(19|20)\d{2}"#)
|
||
let range = NSRange(s.startIndex..., in: s)
|
||
guard yearRegex?.firstMatch(in: s, range: range) != nil else { return "" }
|
||
return s
|
||
}
|
||
|
||
/// Validates a CAS number — must match the XXXXXXX-XX-X pattern.
|
||
private func aiSanitizeCAS(_ value: String) -> String {
|
||
let s = aiSanitize(value)
|
||
guard !s.isEmpty else { return "" }
|
||
let range = NSRange(s.startIndex..., in: s)
|
||
guard (try? NSRegularExpression(pattern: #"^\d{2,7}-\d{2}-\d$"#))?.firstMatch(in: s, range: range) != nil
|
||
else { return "" }
|
||
return s
|
||
}
|
||
|
||
/// Validates a numeric amount — must be a positive number.
|
||
private func aiSanitizeAmount(_ value: String) -> String {
|
||
let s = aiSanitize(value)
|
||
guard !s.isEmpty, let d = Double(s), d > 0 else { return "" }
|
||
return s
|
||
}
|
||
|
||
/// Sanitizes a unit string — must be a known lab unit, not a filler word.
|
||
private let knownUnits: Set<String> = [
|
||
"g", "gm", "mg", "kg", "ml", "ml", "l", "mmol", "mol", "ul", "µl", "oz", "lb"
|
||
]
|
||
private func aiSanitizeUnit(_ value: String) -> String {
|
||
let s = aiSanitize(value)
|
||
guard !s.isEmpty else { return "" }
|
||
return knownUnits.contains(s.lowercased()) ? s : ""
|
||
}
|
||
|
||
// MARK: - Container type options
|
||
|
||
/// All container types available for the user to select.
|
||
let containerTypeOptions: [String] = [
|
||
"Glass Bottle", "Plastic Bottle", "Vial", "Ampoule", "Flask",
|
||
"Beaker", "Tube", "Jar", "Can", "Canister", "Drum", "Bag"
|
||
]
|
||
|
||
|
||
|
||
@available(iOS 18.1, *)
|
||
private func onDeviceLabelLookup(ocrLines: [String]) async -> LabelExtraction? {
|
||
let model = SystemLanguageModel.default
|
||
guard case .available = model.availability else { return nil }
|
||
let session = LanguageModelSession(instructions: labelExtractionInstructions)
|
||
let joined = ocrLines.joined(separator: "\n")
|
||
let prompt = "Label text:\n\(joined)"
|
||
guard var result = try? await session.respond(to: prompt, generating: LabelExtraction.self).content
|
||
else { return nil }
|
||
|
||
// Sanitize every field so callers never receive placeholders like "N/A", "0000-00-00", etc.
|
||
result.chemicalName = aiSanitize(result.chemicalName)
|
||
result.physicalState = aiSanitize(result.physicalState)
|
||
result.vendor = aiSanitize(result.vendor)
|
||
result.casNumber = aiSanitizeCAS(result.casNumber)
|
||
result.lotNumber = aiSanitize(result.lotNumber)
|
||
result.expirationDate = aiSanitizeDate(result.expirationDate)
|
||
result.amount = aiSanitizeAmount(result.amount)
|
||
result.unit = aiSanitizeUnit(result.unit)
|
||
result.catalogNumber = aiSanitize(result.catalogNumber)
|
||
|
||
return result
|
||
}
|
||
|
||
// MARK: - Scanned item (one bottle's worth of data)
|
||
|
||
struct ScannedItem: Identifiable {
|
||
let id = UUID()
|
||
var chemicalName = ""
|
||
var casNumber = ""
|
||
var chemicalFormula = ""
|
||
var molecularWeight = ""
|
||
var vendor = ""
|
||
var catalogNumber = ""
|
||
var lotNumber = ""
|
||
var concentration = ""
|
||
var expirationDate = ""
|
||
var physicalState = ""
|
||
var storageDevice = "Glass Bottle"
|
||
var amountPerContainer = ""
|
||
var unitOfMeasure = ""
|
||
var barcode: String?
|
||
var percentageFull: Double = 50
|
||
var thumbnail: UIImage?
|
||
}
|
||
|
||
// MARK: - Confidence accumulator
|
||
|
||
/// Tracks how many times a given value has been seen for a field.
|
||
/// A field "locks in" once the same value is seen `threshold` times.
|
||
private final class FieldAccumulator {
|
||
private var votes: [String: Int] = [:]
|
||
private let threshold: Int
|
||
|
||
init(threshold: Int = 2) {
|
||
self.threshold = threshold
|
||
}
|
||
|
||
/// Register a new observation. Returns the winning value if it
|
||
/// has now reached the threshold, otherwise nil.
|
||
func observe(_ value: String) -> String? {
|
||
guard !value.trimmingCharacters(in: .whitespaces).isEmpty else { return nil }
|
||
votes[value, default: 0] += 1
|
||
if let (winner, count) = votes.max(by: { $0.value < $1.value }), count >= threshold {
|
||
return winner
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func reset() { votes = [:] }
|
||
|
||
/// Best guess even before threshold (for live preview).
|
||
var bestGuess: String? {
|
||
votes.max(by: { $0.value < $1.value })?.key
|
||
}
|
||
}
|
||
|
||
// MARK: - PubChem lookup
|
||
|
||
private struct PubChemResult {
|
||
var iupacName: String? // raw IUPAC/preferred name from props
|
||
var commonName: String? // best short synonym (e.g. "CHAPS", "HEPES")
|
||
var chemicalFormula: String?
|
||
var molecularWeight: String?
|
||
var physicalState: String?
|
||
|
||
/// The name to actually display: common name if one was found, otherwise IUPAC.
|
||
var bestName: String? { commonName ?? iupacName }
|
||
}
|
||
|
||
/// Patterns that indicate a synonym is a database ID rather than a usable name.
|
||
private let synonymJunkPatterns: [NSRegularExpression] = [
|
||
try! NSRegularExpression(pattern: #"^\d{2,7}-\d{2}-\d$"#), // CAS number
|
||
try! NSRegularExpression(pattern: #"^[A-Z]{2,}[:\-_]\d"#), // DTXSID6…, CHEBI:…
|
||
try! NSRegularExpression(pattern: #"^[A-Z0-9]{8,}$"#), // InChIKey-style all-caps
|
||
try! NSRegularExpression(pattern: #"(?i)InChI="#), // InChI strings
|
||
]
|
||
|
||
private func isJunkSynonym(_ s: String) -> Bool {
|
||
let range = NSRange(s.startIndex..., in: s)
|
||
return synonymJunkPatterns.contains { $0.firstMatch(in: s, range: range) != nil }
|
||
}
|
||
|
||
/// Returns the best human-readable synonym: shortest clean name that isn't the IUPAC name itself.
|
||
/// Prefers names ≤ 30 characters (abbreviations/common names) but will take up to 60 if nothing shorter exists.
|
||
private func bestSynonym(from synonyms: [String], iupacName: String?) -> String? {
|
||
let iupacLower = iupacName?.lowercased() ?? ""
|
||
let candidates = synonyms.filter { s in
|
||
!isJunkSynonym(s) && s.lowercased() != iupacLower && s.count <= 60
|
||
}
|
||
// Prefer short names first (abbreviations like CHAPS, HEPES, SDS)
|
||
if let short = candidates.filter({ $0.count <= 30 }).min(by: { $0.count < $1.count }) {
|
||
return short
|
||
}
|
||
return candidates.min(by: { $0.count < $1.count })
|
||
}
|
||
|
||
private func pubChemLookup(cas: String) async -> PubChemResult? {
|
||
guard !cas.isEmpty,
|
||
let encoded = cas.addingPercentEncoding(withAllowedCharacters: .urlPathAllowed),
|
||
let url = URL(string: "https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/\(encoded)/JSON")
|
||
else { return nil }
|
||
guard let (data, _) = try? await URLSession.shared.data(from: url),
|
||
let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
|
||
let compounds = (json["PC_Compounds"] as? [[String: Any]])?.first
|
||
else { return nil }
|
||
|
||
var result = PubChemResult()
|
||
|
||
// Extract CID for synonym lookup, plus formula/weight/state/IUPAC name
|
||
var cid: Int?
|
||
if let cidVal = compounds["id"] as? [String: Any],
|
||
let cidCompound = cidVal["id"] as? [String: Any],
|
||
let cidInt = cidCompound["cid"] as? Int {
|
||
cid = cidInt
|
||
}
|
||
|
||
if let props = compounds["props"] as? [[String: Any]] {
|
||
for prop in props {
|
||
guard let urn = prop["urn"] as? [String: Any],
|
||
let value = prop["value"] as? [String: Any] else { continue }
|
||
let label = urn["label"] as? String ?? ""
|
||
let name = urn["name"] as? String ?? ""
|
||
if label == "IUPAC Name", name == "Preferred" {
|
||
result.iupacName = value["sval"] as? String
|
||
}
|
||
if label == "Molecular Formula" {
|
||
result.chemicalFormula = value["sval"] as? String
|
||
}
|
||
if label == "Molecular Weight" {
|
||
if let mw = value["fval"] { result.molecularWeight = "\(mw)" }
|
||
else if let mw = value["sval"] as? String { result.molecularWeight = mw }
|
||
}
|
||
if label == "Physical Description" {
|
||
let desc = (value["sval"] as? String ?? "").lowercased()
|
||
if desc.contains("liquid") { result.physicalState = "Liquid" }
|
||
else if desc.contains("solid") || desc.contains("powder") || desc.contains("crystal") {
|
||
result.physicalState = "Solid"
|
||
} else if desc.contains("gas") { result.physicalState = "Gas" }
|
||
}
|
||
}
|
||
}
|
||
|
||
// Fetch synonyms to find common/trade name (e.g. "CHAPS" instead of the long IUPAC string)
|
||
if let cid {
|
||
if let synURL = URL(string: "https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/cid/\(cid)/synonyms/JSON"),
|
||
let (synData, _) = try? await URLSession.shared.data(from: synURL),
|
||
let synJSON = try? JSONSerialization.jsonObject(with: synData) as? [String: Any],
|
||
let infoList = (synJSON["InformationList"] as? [String: Any])?["Information"] as? [[String: Any]],
|
||
let synonyms = infoList.first?["Synonym"] as? [String] {
|
||
result.commonName = bestSynonym(from: synonyms, iupacName: result.iupacName)
|
||
}
|
||
}
|
||
|
||
return result
|
||
}
|
||
|
||
// MARK: - Regex extractors
|
||
|
||
private let casRegex = try! NSRegularExpression(pattern: #"\b(\d{2,7}-\d{2}-\d)\b"#)
|
||
private let lotRegex = try! NSRegularExpression(pattern: #"(?i)(?:lot|lot\s*#|lot\s*no\.?)\s*[:\s]?\s*([A-Z0-9]{4,})"#)
|
||
private let mwRegex = try! NSRegularExpression(pattern: #"(?i)(?:M\.?W\.?|MW|Mol\.?\s*Wt\.?)\s*[:\s]?\s*([\d.,]+)"#)
|
||
private let sizeRegex = try! NSRegularExpression(pattern: #"\b(\d+(?:\.\d+)?)\s*(mL|ml|L|g|gm|kg|mg|oz|lb|gal|mol|mmol|µL|uL)\b"#, options: .caseInsensitive)
|
||
private let expRegex = try! NSRegularExpression(pattern: #"(?i)(?:exp(?:iry|iration)?\.?\s*|use\s*by\s*|best\s*before\s*)(\d{1,2}[/\-]\d{4}|\d{4}[/\-]\d{2}(?:[/\-]\d{2})?|(?:jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)[a-z.]*\s+\d{4}|\d{4})"#)
|
||
|
||
private let knownVendors = ["Sigma-Aldrich", "Sigma Aldrich", "Aldrich", "Millipore Sigma",
|
||
"VWR", "Fisher", "Fisher Scientific", "Thermo Fisher",
|
||
"Acros", "Acros Organics", "BDH", "Amresco", "EMD",
|
||
"Alfa Aesar", "TCI", "Fluka", "J.T. Baker"]
|
||
|
||
private func extract(from lines: [String]) -> [String: String] {
|
||
let full = lines.joined(separator: "\n")
|
||
var fields: [String: String] = [:]
|
||
|
||
func first(regex: NSRegularExpression, in text: String, group: Int = 1) -> String? {
|
||
let range = NSRange(text.startIndex..., in: text)
|
||
guard let m = regex.firstMatch(in: text, range: range),
|
||
let r = Range(m.range(at: group), in: text) else { return nil }
|
||
return String(text[r]).trimmingCharacters(in: .whitespaces)
|
||
}
|
||
|
||
if let cas = first(regex: casRegex, in: full) { fields["cas"] = cas }
|
||
if let lot = first(regex: lotRegex, in: full) { fields["lot"] = lot }
|
||
if let mw = first(regex: mwRegex, in: full) { fields["mw"] = mw }
|
||
if let exp = first(regex: expRegex, in: full) { fields["exp"] = normalizeDate(exp) }
|
||
|
||
if let m = sizeRegex.firstMatch(in: full, range: NSRange(full.startIndex..., in: full)),
|
||
let valRange = Range(m.range(at: 1), in: full),
|
||
let unitRange = Range(m.range(at: 2), in: full) {
|
||
fields["amount"] = String(full[valRange])
|
||
fields["unit"] = String(full[unitRange])
|
||
}
|
||
|
||
for vendor in knownVendors {
|
||
if full.localizedCaseInsensitiveContains(vendor) {
|
||
fields["vendor"] = vendor
|
||
break
|
||
}
|
||
}
|
||
|
||
// Catalog number: line matching vendor catalog patterns like "P0662-500G", "BDH9258-500G"
|
||
for line in lines {
|
||
let trimmed = line.trimmingCharacters(in: .whitespaces)
|
||
if trimmed.range(of: #"^[A-Z]{1,4}\d{3,}-\d+[A-Z]*$"#, options: .regularExpression) != nil {
|
||
fields["catalog"] = trimmed
|
||
break
|
||
}
|
||
}
|
||
|
||
return fields
|
||
}
|
||
|
||
private let monthNames: [String: Int] = [
|
||
"jan": 1, "feb": 2, "mar": 3, "apr": 4, "may": 5, "jun": 6,
|
||
"jul": 7, "aug": 8, "sep": 9, "oct": 10, "nov": 11, "dec": 12
|
||
]
|
||
|
||
private func normalizeDate(_ raw: String) -> String {
|
||
let trimmed = raw.trimmingCharacters(in: .whitespaces)
|
||
|
||
// Month-name formats: "Jun. 2018", "June 2018", "jun 2018"
|
||
let monthNameRegex = try? NSRegularExpression(pattern: #"(?i)^([a-z]{3})[a-z.]*\s+(\d{4})$"#)
|
||
if let m = monthNameRegex?.firstMatch(in: trimmed, range: NSRange(trimmed.startIndex..., in: trimmed)),
|
||
let mRange = Range(m.range(at: 1), in: trimmed),
|
||
let yRange = Range(m.range(at: 2), in: trimmed),
|
||
let month = monthNames[String(trimmed[mRange]).lowercased()],
|
||
let year = Int(trimmed[yRange]) {
|
||
return String(format: "%04d-%02d-01", year, month)
|
||
}
|
||
|
||
// Numeric formats: MM/YYYY, MM-YYYY, YYYY/MM, YYYY-MM, YYYY-MM-DD
|
||
let parts = trimmed.components(separatedBy: CharacterSet(charactersIn: "/-"))
|
||
if parts.count == 2 {
|
||
if parts[0].count <= 2, let month = Int(parts[0]), let year = Int(parts[1]), year > 2000 {
|
||
return String(format: "%04d-%02d-01", year, month)
|
||
}
|
||
if parts[0].count == 4, let year = Int(parts[0]), let month = Int(parts[1]) {
|
||
return String(format: "%04d-%02d-01", year, month)
|
||
}
|
||
}
|
||
if parts.count == 3, parts[0].count == 4 {
|
||
return "\(parts[0])-\(parts[1].padLeft(2))-\(parts[2].padLeft(2))"
|
||
}
|
||
return trimmed
|
||
}
|
||
|
||
private extension String {
|
||
func padLeft(_ length: Int) -> String {
|
||
count >= length ? self : String(repeating: "0", count: length - count) + self
|
||
}
|
||
}
|
||
|
||
// MARK: - Scanner view model
|
||
|
||
@Observable
|
||
@MainActor
|
||
final class LabelScannerViewModel {
|
||
// Session state
|
||
var isScanning = false // live scanning session active
|
||
var scannedItems: [ScannedItem] = []
|
||
var showReview = false
|
||
|
||
// Current item being built
|
||
var current = ScannedItem()
|
||
var isLookingUpPubChem = false
|
||
|
||
// Live preview fields (best-guess, updates every frame)
|
||
var previewFields: [String: String] = [:]
|
||
|
||
// Profile (pre-filled on location fields)
|
||
var piFirstName = ""
|
||
var bldgCode = ""
|
||
var lab = ""
|
||
var storageLocation = ""
|
||
var contact = ""
|
||
|
||
// Accumulators for current item.
|
||
// CAS uses a higher threshold — a partial OCR read (e.g. missing last digit) looks valid
|
||
// to the regex but is wrong. More votes = more confidence before committing.
|
||
private var accumulators: [String: FieldAccumulator] = [
|
||
"cas": FieldAccumulator(threshold: 3),
|
||
"lot": FieldAccumulator(threshold: 2),
|
||
"mw": FieldAccumulator(threshold: 2),
|
||
"exp": FieldAccumulator(threshold: 2),
|
||
"amount": FieldAccumulator(threshold: 2),
|
||
"unit": FieldAccumulator(threshold: 2),
|
||
"vendor": FieldAccumulator(threshold: 2),
|
||
"catalog": FieldAccumulator(threshold: 2),
|
||
]
|
||
|
||
// Tracks the last CAS number used to kick off a PubChem task.
|
||
// If the accumulator later converges on a different CAS, we cancel and retry.
|
||
private var lastPubChemCAS: String = ""
|
||
// True if the last PubChem lookup returned no result (so AI should keep running)
|
||
private var pubChemFailed = false
|
||
|
||
// Tracks which fields have been confirmed by the regex accumulator (2+ OCR votes).
|
||
// AI results never overwrite these — regex-confirmed data is more trustworthy for structured fields.
|
||
private var lockedByRegex: Set<String> = []
|
||
|
||
// Barcode: first hit wins (no need for accumulation)
|
||
private var barcodeHandled = false
|
||
private var pendingBarcode: String? // barcode seen before scanning started
|
||
private var pubChemTask: Task<Void, Never>?
|
||
|
||
// On-device AI extraction
|
||
var isRunningAI = false
|
||
private var aiTask: Task<Void, Never>?
|
||
private var allOCRLines: Set<String> = [] // accumulates unique lines seen across frames
|
||
private var aiTriggered = false
|
||
private var aiNameConfidence: Int = 0 // confidence of the currently applied AI name
|
||
private var lastAITriggerTime: Date = .distantPast // wall-clock time of last AI trigger
|
||
private var aiSatisfied = false // true once names have been reconciled — no more AI re-triggers
|
||
// Incremented on every resetScanState(). Async tasks capture this value at launch;
|
||
// if it differs when they complete, the result belongs to a previous scan and is discarded.
|
||
private var scanGeneration: Int = 0
|
||
// True once the user has picked a container type for this scan.
|
||
var containerTypeSelected = false
|
||
// True when the container type picker sheet should be shown.
|
||
var showContainerTypePicker = false
|
||
|
||
// Debug info shown in banner
|
||
var debugBarcode: String = "—"
|
||
var debugOCRLineCount: Int = 0
|
||
var debugPubChemName: String = "—" // raw name returned by PubChem
|
||
var debugAIName: String = "—" // name extracted by on-device AI (with confidence)
|
||
var debugArbitration: String = "—" // result of name arbitration
|
||
|
||
var debugAIQueryCount: Int = 0 // how many times the AI extraction has been triggered
|
||
var allOCRLinesCount: Int { allOCRLines.count }
|
||
var showDebug: Bool = false
|
||
|
||
private let profileClient = ProfileClient()
|
||
|
||
func loadProfile() async {
|
||
if let profile = try? await profileClient.get() {
|
||
piFirstName = profile.piFirstName ?? ""
|
||
bldgCode = profile.bldgCode ?? ""
|
||
lab = profile.lab ?? ""
|
||
contact = profile.contact ?? ""
|
||
}
|
||
}
|
||
|
||
// Called from camera coordinator on every recognized-items update (~every 0.5s)
|
||
func processFrame(texts: [String], barcode: String?, barcodeDebug: String?, thumbnail: UIImage?) {
|
||
guard isScanning else {
|
||
// Still buffer barcodes seen before play is tapped
|
||
if let bc = barcode {
|
||
pendingBarcode = bc
|
||
debugBarcode = "buffered: \(barcodeDebug ?? bc)"
|
||
}
|
||
return
|
||
}
|
||
|
||
// Keep thumbnail fresh every frame (used by the fill slider preview)
|
||
if let thumb = thumbnail {
|
||
current.thumbnail = thumb
|
||
}
|
||
|
||
// Debug: track OCR line count every frame
|
||
debugOCRLineCount = texts.count
|
||
|
||
// Buffer barcode even before scanning starts so we don't miss a quick read
|
||
if let bc = barcode {
|
||
pendingBarcode = bc
|
||
debugBarcode = barcodeDebug ?? bc
|
||
}
|
||
|
||
// Apply barcode on first hit once scanning is active
|
||
if let bc = pendingBarcode, !barcodeHandled {
|
||
barcodeHandled = true
|
||
current.barcode = bc
|
||
debugBarcode = "locked: \(debugBarcode)"
|
||
if current.catalogNumber.isEmpty {
|
||
current.catalogNumber = bc
|
||
previewFields["catalog"] = bc
|
||
}
|
||
}
|
||
|
||
// OCR extraction
|
||
let extracted = extract(from: texts)
|
||
|
||
for (key, value) in extracted {
|
||
let acc = accumulators[key]
|
||
if let locked = acc?.observe(value) {
|
||
applyLocked(key: key, value: locked)
|
||
}
|
||
// Always update preview with best guess
|
||
if let guess = acc?.bestGuess ?? value as String? {
|
||
previewFields[key] = guess
|
||
}
|
||
}
|
||
|
||
// Accumulate all OCR lines seen for AI extraction
|
||
for line in texts {
|
||
let trimmed = line.trimmingCharacters(in: .whitespacesAndNewlines)
|
||
if !trimmed.isEmpty { allOCRLines.insert(trimmed) }
|
||
}
|
||
|
||
// Trigger on-device AI name extraction when:
|
||
// - No CAS found yet, OR CAS was found but PubChem failed for it, AND
|
||
// - Either not yet triggered, OR 5 seconds have passed and no AI query is running
|
||
let enoughTimeSinceLastAI = Date().timeIntervalSince(lastAITriggerTime) >= 5
|
||
let pubChemUnavailable = current.casNumber.isEmpty || pubChemFailed
|
||
if !aiSatisfied, pubChemUnavailable, allOCRLines.count >= 6,
|
||
(!aiTriggered || (enoughTimeSinceLastAI && !isRunningAI)) {
|
||
triggerAIExtraction()
|
||
}
|
||
|
||
// Kick off PubChem lookup when CAS locks in, or retry if CAS has changed
|
||
if !current.casNumber.isEmpty, current.casNumber != lastPubChemCAS {
|
||
let cas = current.casNumber
|
||
lastPubChemCAS = cas
|
||
pubChemFailed = false
|
||
pubChemTask?.cancel()
|
||
pubChemTask = nil
|
||
debugPubChemName = "querying…"
|
||
debugArbitration = "—"
|
||
pubChemTask = Task {
|
||
isLookingUpPubChem = true
|
||
if let result = await pubChemLookup(cas: cas) {
|
||
// Ignore result if CAS has changed again while we were waiting
|
||
guard cas == current.casNumber else {
|
||
isLookingUpPubChem = false
|
||
return
|
||
}
|
||
if current.chemicalFormula.isEmpty, let f = result.chemicalFormula {
|
||
current.chemicalFormula = f
|
||
}
|
||
if current.molecularWeight.isEmpty, let mw = result.molecularWeight {
|
||
current.molecularWeight = mw
|
||
}
|
||
if current.physicalState.isEmpty, let ps = result.physicalState {
|
||
current.physicalState = ps
|
||
}
|
||
|
||
// Build debug string showing both names
|
||
let iupac = result.iupacName ?? ""
|
||
let common = result.commonName ?? ""
|
||
debugPubChemName = common.isEmpty
|
||
? (iupac.isEmpty ? "no name" : iupac)
|
||
: "\(common) [\(iupac.prefix(20))…]"
|
||
|
||
if let bestName = result.bestName {
|
||
current.chemicalName = bestName
|
||
previewFields["name"] = bestName
|
||
debugArbitration = result.commonName != nil ? "synonym▶︎\(bestName)" : "IUPAC▶︎\(bestName)"
|
||
} else {
|
||
debugArbitration = "no name from PubChem"
|
||
}
|
||
// PubChem result is definitive — stop AI from overriding
|
||
aiNameConfidence = 100
|
||
aiSatisfied = true
|
||
} else {
|
||
debugPubChemName = "failed for \(cas)"
|
||
debugArbitration = "—"
|
||
pubChemFailed = true // allow AI to keep running as fallback
|
||
}
|
||
isLookingUpPubChem = false
|
||
}
|
||
}
|
||
}
|
||
|
||
private func triggerAIExtraction() {
|
||
aiTriggered = true
|
||
aiTask?.cancel()
|
||
aiTask = nil
|
||
let lines = Array(allOCRLines)
|
||
lastAITriggerTime = Date()
|
||
debugAIQueryCount += 1
|
||
debugAIName = "querying #\(debugAIQueryCount)…"
|
||
let generation = scanGeneration
|
||
aiTask = Task {
|
||
isRunningAI = true
|
||
if #available(iOS 18.1, *) {
|
||
if let result = await onDeviceLabelLookup(ocrLines: lines),
|
||
generation == scanGeneration {
|
||
let conf = result.nameConfidence
|
||
let extracted = result.chemicalName.isEmpty ? "—" : result.chemicalName
|
||
debugAIName = "\(extracted) (\(conf)%)"
|
||
// Apply name if: confident enough AND (no name yet OR higher confidence than previous AI guess)
|
||
if !result.chemicalName.isEmpty, conf >= aiNameConfidenceThreshold,
|
||
(current.chemicalName.isEmpty || conf > aiNameConfidence) {
|
||
current.chemicalName = result.chemicalName
|
||
previewFields["name"] = result.chemicalName
|
||
aiNameConfidence = conf
|
||
}
|
||
// For secondary fields: AI can freely write or update values unless
|
||
// the regex accumulator has already confirmed them (2+ OCR votes = more reliable).
|
||
if !result.physicalState.isEmpty {
|
||
current.physicalState = result.physicalState
|
||
}
|
||
if !lockedByRegex.contains("vendor"), !result.vendor.isEmpty {
|
||
current.vendor = result.vendor
|
||
previewFields["vendor"] = result.vendor
|
||
}
|
||
// CAS: only fill from AI if regex hasn't seen it — regex is more reliable for structured numbers
|
||
if !lockedByRegex.contains("cas"), !result.casNumber.isEmpty {
|
||
current.casNumber = result.casNumber
|
||
previewFields["cas"] = result.casNumber
|
||
}
|
||
if !lockedByRegex.contains("lot"), !result.lotNumber.isEmpty {
|
||
current.lotNumber = result.lotNumber
|
||
previewFields["lot"] = result.lotNumber
|
||
}
|
||
if !lockedByRegex.contains("exp"), !result.expirationDate.isEmpty {
|
||
current.expirationDate = normalizeDate(result.expirationDate)
|
||
previewFields["exp"] = current.expirationDate
|
||
}
|
||
if !lockedByRegex.contains("amount"), !result.amount.isEmpty {
|
||
current.amountPerContainer = result.amount
|
||
previewFields["amount"] = result.amount
|
||
}
|
||
if !lockedByRegex.contains("unit"), !result.unit.isEmpty {
|
||
current.unitOfMeasure = result.unit
|
||
previewFields["unit"] = result.unit
|
||
}
|
||
if !lockedByRegex.contains("catalog"), !result.catalogNumber.isEmpty {
|
||
current.catalogNumber = result.catalogNumber
|
||
previewFields["catalog"] = result.catalogNumber
|
||
}
|
||
} else {
|
||
debugAIName = "unavailable"
|
||
}
|
||
} else {
|
||
debugAIName = "iOS 18.1+ req"
|
||
}
|
||
isRunningAI = false
|
||
}
|
||
}
|
||
|
||
private func applyLocked(key: String, value: String) {
|
||
// Mark field as regex-confirmed. AI will not overwrite these.
|
||
lockedByRegex.insert(key)
|
||
switch key {
|
||
case "cas":
|
||
current.casNumber = value
|
||
case "lot":
|
||
current.lotNumber = value
|
||
case "mw":
|
||
current.molecularWeight = value
|
||
case "exp":
|
||
current.expirationDate = value
|
||
case "amount":
|
||
current.amountPerContainer = value
|
||
case "unit":
|
||
current.unitOfMeasure = value
|
||
case "vendor":
|
||
current.vendor = value
|
||
case "catalog":
|
||
current.catalogNumber = value
|
||
default: break
|
||
}
|
||
}
|
||
|
||
private func resetScanState() {
|
||
scanGeneration += 1
|
||
resetAccumulators()
|
||
current = ScannedItem()
|
||
previewFields = [:]
|
||
lockedByRegex = []
|
||
barcodeHandled = false
|
||
pendingBarcode = nil
|
||
pubChemTask?.cancel()
|
||
pubChemTask = nil
|
||
lastPubChemCAS = ""
|
||
pubChemFailed = false
|
||
aiTask?.cancel()
|
||
aiTask = nil
|
||
isRunningAI = false
|
||
containerTypeSelected = false
|
||
showContainerTypePicker = false
|
||
aiTriggered = false
|
||
aiNameConfidence = 0
|
||
lastAITriggerTime = .distantPast
|
||
aiSatisfied = false
|
||
allOCRLines = []
|
||
debugBarcode = "—"
|
||
debugOCRLineCount = 0
|
||
debugPubChemName = "—"
|
||
debugAIName = "—"
|
||
debugArbitration = "—"
|
||
debugAIQueryCount = 0
|
||
isLookingUpPubChem = false
|
||
}
|
||
|
||
func startScanning() {
|
||
resetScanState()
|
||
isScanning = true
|
||
showContainerTypePicker = true
|
||
}
|
||
|
||
func stopScanning() {
|
||
isScanning = false
|
||
|
||
let snapshot = current
|
||
scannedItems.append(snapshot)
|
||
let appendedIndex = scannedItems.count - 1
|
||
|
||
// Cancel any in-flight tasks before starting the post-stop AI pass
|
||
pubChemTask?.cancel()
|
||
pubChemTask = nil
|
||
|
||
// Final AI pass — update the already-appended item when it completes
|
||
if snapshot.chemicalName.isEmpty, !allOCRLines.isEmpty {
|
||
let lines = Array(allOCRLines)
|
||
let lockedSnapshot = lockedByRegex // capture by value — resetScanState clears the original
|
||
let generation = scanGeneration
|
||
debugAIQueryCount += 1
|
||
debugAIName = "querying #\(debugAIQueryCount) (post-stop)…"
|
||
aiTask?.cancel()
|
||
aiTask = Task {
|
||
isRunningAI = true
|
||
if #available(iOS 18.1, *) {
|
||
if let result = await onDeviceLabelLookup(ocrLines: lines),
|
||
generation == scanGeneration,
|
||
appendedIndex < scannedItems.count {
|
||
let conf = result.nameConfidence
|
||
let extracted = result.chemicalName.isEmpty ? "—" : result.chemicalName
|
||
debugAIName = "\(extracted) (\(conf)%)"
|
||
if !result.chemicalName.isEmpty, conf >= aiNameConfidenceThreshold,
|
||
(scannedItems[appendedIndex].chemicalName.isEmpty || conf > aiNameConfidence) {
|
||
scannedItems[appendedIndex].chemicalName = result.chemicalName
|
||
}
|
||
if !result.physicalState.isEmpty {
|
||
scannedItems[appendedIndex].physicalState = result.physicalState
|
||
}
|
||
if !lockedSnapshot.contains("vendor"), !result.vendor.isEmpty {
|
||
scannedItems[appendedIndex].vendor = result.vendor
|
||
}
|
||
if !lockedSnapshot.contains("cas"), !result.casNumber.isEmpty {
|
||
scannedItems[appendedIndex].casNumber = result.casNumber
|
||
}
|
||
if !lockedSnapshot.contains("lot"), !result.lotNumber.isEmpty {
|
||
scannedItems[appendedIndex].lotNumber = result.lotNumber
|
||
}
|
||
if !lockedSnapshot.contains("exp"), !result.expirationDate.isEmpty {
|
||
scannedItems[appendedIndex].expirationDate = normalizeDate(result.expirationDate)
|
||
}
|
||
if !lockedSnapshot.contains("amount"), !result.amount.isEmpty {
|
||
scannedItems[appendedIndex].amountPerContainer = result.amount
|
||
}
|
||
if !lockedSnapshot.contains("unit"), !result.unit.isEmpty {
|
||
scannedItems[appendedIndex].unitOfMeasure = result.unit
|
||
}
|
||
if !lockedSnapshot.contains("catalog"), !result.catalogNumber.isEmpty {
|
||
scannedItems[appendedIndex].catalogNumber = result.catalogNumber
|
||
}
|
||
} else {
|
||
debugAIName = "unavailable"
|
||
}
|
||
} else {
|
||
debugAIName = "iOS 18.1+ req"
|
||
}
|
||
isRunningAI = false
|
||
}
|
||
}
|
||
}
|
||
|
||
func finishSession() {
|
||
isScanning = false
|
||
showReview = true
|
||
}
|
||
|
||
private func resetAccumulators() {
|
||
accumulators.values.forEach { $0.reset() }
|
||
}
|
||
}
|
||
|
||
// MARK: - ScanView (main)
|
||
|
||
struct ScanView: View {
|
||
@Environment(\.dismiss) private var dismiss
|
||
@State private var viewModel = LabelScannerViewModel()
|
||
|
||
var body: some View {
|
||
NavigationStack {
|
||
ZStack {
|
||
// Camera feed (always live)
|
||
if DataScannerViewController.isSupported && DataScannerViewController.isAvailable {
|
||
LiveScannerView(viewModel: viewModel)
|
||
.ignoresSafeArea()
|
||
} else {
|
||
Color.black.ignoresSafeArea()
|
||
ContentUnavailableView(
|
||
"Scanner Unavailable",
|
||
systemImage: "camera.slash",
|
||
description: Text("This device does not support scanning.")
|
||
)
|
||
}
|
||
|
||
// Overlay
|
||
VStack(spacing: 0) {
|
||
// Banner
|
||
if viewModel.isScanning {
|
||
ScanBanner(viewModel: viewModel)
|
||
.transition(.move(edge: .top).combined(with: .opacity))
|
||
}
|
||
|
||
Spacer()
|
||
|
||
// Bottom controls
|
||
ScanBottomBar(viewModel: viewModel)
|
||
}
|
||
}
|
||
.navigationBarTitleDisplayMode(.inline)
|
||
.toolbarBackground(.hidden, for: .navigationBar)
|
||
.toolbar {
|
||
ToolbarItem(placement: .topBarLeading) {
|
||
Button("Cancel") { dismiss() }
|
||
.foregroundStyle(.white)
|
||
.shadow(radius: 2)
|
||
}
|
||
ToolbarItem(placement: .topBarTrailing) {
|
||
if !viewModel.scannedItems.isEmpty && !viewModel.isScanning {
|
||
Button {
|
||
viewModel.finishSession()
|
||
} label: {
|
||
HStack(spacing: 4) {
|
||
Image(systemName: "checkmark")
|
||
Text("Done (\(viewModel.scannedItems.count))")
|
||
}
|
||
.fontWeight(.semibold)
|
||
}
|
||
.foregroundStyle(.white)
|
||
.shadow(radius: 2)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
.task { await viewModel.loadProfile() }
|
||
.sheet(isPresented: $viewModel.showReview) {
|
||
ScanReviewView(viewModel: viewModel, onDone: { dismiss() })
|
||
}
|
||
.sheet(isPresented: $viewModel.showContainerTypePicker) {
|
||
ContainerTypePickerSheet(viewModel: viewModel)
|
||
.presentationDetents([.medium])
|
||
.presentationDragIndicator(.visible)
|
||
}
|
||
.animation(.easeInOut(duration: 0.3), value: viewModel.isScanning)
|
||
}
|
||
}
|
||
|
||
// MARK: - Live scanner UIViewControllerRepresentable
|
||
|
||
struct LiveScannerView: UIViewControllerRepresentable {
|
||
let viewModel: LabelScannerViewModel
|
||
|
||
func makeUIViewController(context: Context) -> DataScannerViewController {
|
||
let scanner = DataScannerViewController(
|
||
recognizedDataTypes: [.text(), .barcode()],
|
||
qualityLevel: .accurate,
|
||
recognizesMultipleItems: true,
|
||
isHighFrameRateTrackingEnabled: false,
|
||
isHighlightingEnabled: false // we draw our own banner, no overlays needed
|
||
)
|
||
scanner.delegate = context.coordinator
|
||
context.coordinator.viewModel = viewModel
|
||
try? scanner.startScanning()
|
||
return scanner
|
||
}
|
||
|
||
func updateUIViewController(_ uiViewController: DataScannerViewController, context: Context) {}
|
||
|
||
func makeCoordinator() -> Coordinator { Coordinator() }
|
||
|
||
@MainActor
|
||
final class Coordinator: NSObject, DataScannerViewControllerDelegate, @unchecked Sendable {
|
||
var viewModel: LabelScannerViewModel?
|
||
private var lastProcessed = Date.distantPast
|
||
|
||
func dataScanner(_ dataScanner: DataScannerViewController, didAdd addedItems: [RecognizedItem], allItems: [RecognizedItem]) {
|
||
// Process immediately when new items are first recognized (catches barcodes that don't trigger didUpdate)
|
||
processItems(allItems, in: dataScanner, forceBarcode: true)
|
||
}
|
||
|
||
func dataScanner(_ dataScanner: DataScannerViewController, didUpdate updatedItems: [RecognizedItem], allItems: [RecognizedItem]) {
|
||
// Throttle to ~2 frames/sec to avoid hammering
|
||
let now = Date()
|
||
guard now.timeIntervalSince(lastProcessed) >= 0.5 else { return }
|
||
lastProcessed = now
|
||
processItems(allItems, in: dataScanner, forceBarcode: false)
|
||
}
|
||
|
||
private func processItems(_ allItems: [RecognizedItem], in dataScanner: DataScannerViewController, forceBarcode: Bool) {
|
||
var texts: [String] = []
|
||
var barcode: String? // raw payload stored in the item
|
||
var barcodeDebug: String? // includes symbology, shown on screen only
|
||
for item in allItems {
|
||
switch item {
|
||
case .text(let t): texts.append(t.transcript)
|
||
case .barcode(let b):
|
||
if let p = b.payloadStringValue {
|
||
barcode = p
|
||
let sym = b.observation.symbology.rawValue.replacingOccurrences(of: "VNBarcodeSymbology", with: "")
|
||
barcodeDebug = "[\(sym)] \(p)"
|
||
}
|
||
default: break
|
||
}
|
||
}
|
||
|
||
// Skip if no barcode found and this was only called for barcode detection
|
||
if forceBarcode && barcode == nil { return }
|
||
|
||
// Capture thumbnail
|
||
let thumb: UIImage? = {
|
||
let renderer = UIGraphicsImageRenderer(bounds: dataScanner.view.bounds)
|
||
return renderer.image { ctx in dataScanner.view.layer.render(in: ctx.cgContext) }
|
||
}()
|
||
|
||
Task { @MainActor in
|
||
viewModel?.processFrame(texts: texts, barcode: barcode, barcodeDebug: barcodeDebug, thumbnail: thumb)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// MARK: - Container type picker sheet
|
||
|
||
struct ContainerTypePickerSheet: View {
|
||
@Bindable var viewModel: LabelScannerViewModel
|
||
|
||
var body: some View {
|
||
VStack(alignment: .leading, spacing: 0) {
|
||
Text("Container Type")
|
||
.font(.headline)
|
||
.padding(.horizontal)
|
||
.padding(.top, 20)
|
||
.padding(.bottom, 12)
|
||
|
||
ScrollView {
|
||
LazyVGrid(columns: [GridItem(.flexible()), GridItem(.flexible())], spacing: 12) {
|
||
ForEach(containerTypeOptions, id: \.self) { option in
|
||
let isSelected = viewModel.current.storageDevice == option
|
||
Button {
|
||
viewModel.current.storageDevice = option
|
||
viewModel.previewFields["container"] = option
|
||
viewModel.containerTypeSelected = true
|
||
viewModel.showContainerTypePicker = false
|
||
} label: {
|
||
Text(option)
|
||
.font(.subheadline)
|
||
.frame(maxWidth: .infinity)
|
||
.padding(.vertical, 14)
|
||
.background(isSelected ? Color.accentColor : Color(.secondarySystemBackground))
|
||
.foregroundStyle(isSelected ? .white : .primary)
|
||
.clipShape(RoundedRectangle(cornerRadius: 10))
|
||
}
|
||
}
|
||
}
|
||
.padding(.horizontal)
|
||
.padding(.bottom, 20)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// MARK: - Scan banner
|
||
|
||
struct ScanBanner: View {
|
||
@Bindable var viewModel: LabelScannerViewModel
|
||
|
||
var body: some View {
|
||
VStack(alignment: .leading, spacing: 0) {
|
||
// Header
|
||
HStack {
|
||
if viewModel.isLookingUpPubChem || viewModel.isRunningAI {
|
||
ProgressView().scaleEffect(0.7).tint(.white)
|
||
} else {
|
||
Image(systemName: "checkmark.circle.fill")
|
||
.foregroundStyle(Color(.brandPrimary))
|
||
}
|
||
Text("Scanning…")
|
||
.font(.subheadline.weight(.semibold))
|
||
.foregroundStyle(.white)
|
||
Spacer()
|
||
Button {
|
||
viewModel.showDebug.toggle()
|
||
} label: {
|
||
Label("Debug", systemImage: viewModel.showDebug ? "chevron.up.circle.fill" : "chevron.down.circle")
|
||
.font(.caption2)
|
||
.foregroundStyle(.white.opacity(viewModel.showDebug ? 1 : 0.55))
|
||
.labelStyle(.iconOnly)
|
||
}
|
||
.buttonStyle(.plain)
|
||
}
|
||
.padding(.horizontal, 16)
|
||
.padding(.top, 12)
|
||
.padding(.bottom, 8)
|
||
|
||
Divider().background(.white.opacity(0.3))
|
||
|
||
// Fields grid
|
||
let fields: [(String, String)] = [
|
||
("Chemical", viewModel.current.chemicalName.isEmpty
|
||
? (viewModel.previewFields["name"] ?? "—") : viewModel.current.chemicalName),
|
||
("CAS", viewModel.current.casNumber.isEmpty
|
||
? (viewModel.previewFields["cas"] ?? "—") : viewModel.current.casNumber),
|
||
("Lot", viewModel.current.lotNumber.isEmpty
|
||
? (viewModel.previewFields["lot"] ?? "—") : viewModel.current.lotNumber),
|
||
("Vendor", viewModel.current.vendor.isEmpty
|
||
? (viewModel.previewFields["vendor"] ?? "—") : viewModel.current.vendor),
|
||
("Amount", viewModel.current.amountPerContainer.isEmpty
|
||
? amountPreview : "\(viewModel.current.amountPerContainer) \(viewModel.current.unitOfMeasure)"),
|
||
("Exp", viewModel.current.expirationDate.isEmpty
|
||
? (viewModel.previewFields["exp"] ?? "—") : viewModel.current.expirationDate),
|
||
("Container", viewModel.current.storageDevice.isEmpty
|
||
? (viewModel.previewFields["container"] ?? "—") : viewModel.current.storageDevice),
|
||
]
|
||
|
||
LazyVGrid(columns: [GridItem(.flexible()), GridItem(.flexible())], spacing: 6) {
|
||
ForEach(fields, id: \.0) { label, value in
|
||
BannerField(label: label, value: value)
|
||
}
|
||
}
|
||
.padding(.horizontal, 16)
|
||
.padding(.vertical, 10)
|
||
|
||
// Debug strip (collapsible)
|
||
if viewModel.showDebug {
|
||
Divider().background(.white.opacity(0.2))
|
||
VStack(alignment: .leading, spacing: 2) {
|
||
HStack(spacing: 4) {
|
||
Text("BCR").font(.system(size: 9, design: .monospaced)).foregroundStyle(.yellow.opacity(0.7)).frame(width: 28, alignment: .leading)
|
||
Text(viewModel.debugBarcode).font(.system(size: 9, design: .monospaced)).foregroundStyle(.yellow).lineLimit(1).truncationMode(.middle)
|
||
}
|
||
HStack(spacing: 4) {
|
||
Text("OCR").font(.system(size: 9, design: .monospaced)).foregroundStyle(.cyan.opacity(0.7)).frame(width: 28, alignment: .leading)
|
||
Text("\(viewModel.debugOCRLineCount) lines · \(viewModel.allOCRLinesCount) unique accumulated").font(.system(size: 9, design: .monospaced)).foregroundStyle(.cyan).lineLimit(1)
|
||
}
|
||
HStack(spacing: 4) {
|
||
Text("AI×\(viewModel.debugAIQueryCount)").font(.system(size: 9, design: .monospaced)).foregroundStyle(.orange.opacity(0.7)).frame(width: 28, alignment: .leading)
|
||
Text(viewModel.debugAIName).font(.system(size: 9, design: .monospaced)).foregroundStyle(.orange).lineLimit(1).truncationMode(.tail)
|
||
}
|
||
HStack(spacing: 4) {
|
||
Text("PUB").font(.system(size: 9, design: .monospaced)).foregroundStyle(.green.opacity(0.7)).frame(width: 28, alignment: .leading)
|
||
Text(viewModel.debugPubChemName).font(.system(size: 9, design: .monospaced)).foregroundStyle(.green).lineLimit(1).truncationMode(.tail)
|
||
}
|
||
HStack(spacing: 4) {
|
||
Text("ARB").font(.system(size: 9, design: .monospaced)).foregroundStyle(.mint.opacity(0.7)).frame(width: 28, alignment: .leading)
|
||
Text(viewModel.debugArbitration).font(.system(size: 9, design: .monospaced)).foregroundStyle(.mint).lineLimit(1).truncationMode(.tail)
|
||
}
|
||
|
||
}
|
||
.padding(.horizontal, 16)
|
||
.padding(.vertical, 6)
|
||
.transition(.opacity.combined(with: .move(edge: .top)))
|
||
}
|
||
|
||
// Fill slider
|
||
HStack(spacing: 12) {
|
||
Text("Fill level")
|
||
.font(.caption)
|
||
.foregroundStyle(.white.opacity(0.8))
|
||
Slider(value: $viewModel.current.percentageFull, in: 0...100, step: 5)
|
||
.tint(Color(.brandPrimary))
|
||
Text("\(Int(viewModel.current.percentageFull))%")
|
||
.font(.caption.monospacedDigit())
|
||
.foregroundStyle(.white)
|
||
.frame(width: 36, alignment: .trailing)
|
||
}
|
||
.padding(.horizontal, 16)
|
||
.padding(.bottom, 12)
|
||
}
|
||
.background(.ultraThinMaterial.opacity(0.92))
|
||
.background(Color.black.opacity(0.55))
|
||
.animation(.easeInOut(duration: 0.2), value: viewModel.showDebug)
|
||
}
|
||
|
||
private var amountPreview: String {
|
||
let a = viewModel.previewFields["amount"] ?? ""
|
||
let u = viewModel.previewFields["unit"] ?? ""
|
||
return (a.isEmpty && u.isEmpty) ? "—" : "\(a) \(u)".trimmingCharacters(in: .whitespaces)
|
||
}
|
||
}
|
||
|
||
private struct BannerField: View {
|
||
let label: String
|
||
let value: String
|
||
var locked: Bool { value != "—" }
|
||
|
||
var body: some View {
|
||
HStack(spacing: 4) {
|
||
Text(label)
|
||
.font(.caption2)
|
||
.foregroundStyle(.white.opacity(0.6))
|
||
.frame(width: 46, alignment: .leading)
|
||
Text(value)
|
||
.font(.caption.weight(locked ? .semibold : .regular))
|
||
.foregroundStyle(locked ? .white : .white.opacity(0.4))
|
||
.lineLimit(1)
|
||
.truncationMode(.tail)
|
||
}
|
||
.frame(maxWidth: .infinity, alignment: .leading)
|
||
}
|
||
}
|
||
|
||
// MARK: - Bottom bar
|
||
|
||
struct ScanBottomBar: View {
|
||
let viewModel: LabelScannerViewModel
|
||
|
||
var body: some View {
|
||
HStack(spacing: 24) {
|
||
// Scanned count badge
|
||
VStack(spacing: 2) {
|
||
Text("\(viewModel.scannedItems.count)")
|
||
.font(.title2.bold())
|
||
.foregroundStyle(.white)
|
||
Text("saved")
|
||
.font(.caption2)
|
||
.foregroundStyle(.white.opacity(0.7))
|
||
}
|
||
.frame(width: 52)
|
||
|
||
// Start / Stop button
|
||
Button {
|
||
if viewModel.isScanning {
|
||
viewModel.stopScanning()
|
||
} else {
|
||
viewModel.startScanning()
|
||
}
|
||
} label: {
|
||
ZStack {
|
||
Circle()
|
||
.fill(viewModel.isScanning ? Color(.brandDestructive) : Color(.brandPrimary))
|
||
.frame(width: 72, height: 72)
|
||
Image(systemName: viewModel.isScanning ? "stop.fill" : "play.fill")
|
||
.font(.title2)
|
||
.foregroundStyle(.white)
|
||
}
|
||
}
|
||
.shadow(radius: 4)
|
||
|
||
// Hint
|
||
VStack(spacing: 2) {
|
||
Text(viewModel.isScanning ? "Tap stop\nwhen done" : "Tap play\nto start")
|
||
.font(.caption2)
|
||
.foregroundStyle(.white.opacity(0.7))
|
||
.multilineTextAlignment(.center)
|
||
}
|
||
.frame(width: 52)
|
||
}
|
||
.padding(.vertical, 20)
|
||
.padding(.horizontal, 32)
|
||
.background(.ultraThinMaterial.opacity(0.85))
|
||
.background(Color.black.opacity(0.4))
|
||
}
|
||
}
|
||
|
||
// MARK: - Review view
|
||
|
||
struct ScanReviewView: View {
|
||
@Bindable var viewModel: LabelScannerViewModel
|
||
let onDone: () -> Void
|
||
|
||
@State private var isSavingAll = false
|
||
@State private var saveError: String?
|
||
@State private var editingItem: ScannedItem?
|
||
@State private var savedCount = 0
|
||
|
||
private let chemicalsClient = ChemicalsClient()
|
||
|
||
var body: some View {
|
||
NavigationStack {
|
||
List {
|
||
Section {
|
||
Text("Review \(viewModel.scannedItems.count) scanned item\(viewModel.scannedItems.count == 1 ? "" : "s"). Tap any item to edit before saving.")
|
||
.font(.subheadline)
|
||
.foregroundStyle(.secondary)
|
||
}
|
||
|
||
ForEach(viewModel.scannedItems) { item in
|
||
ScannedItemRow(item: item)
|
||
.contentShape(Rectangle())
|
||
.onTapGesture { editingItem = item }
|
||
.swipeActions(edge: .trailing) {
|
||
Button(role: .destructive) {
|
||
viewModel.scannedItems.removeAll { $0.id == item.id }
|
||
} label: {
|
||
Label("Delete", systemImage: "trash")
|
||
}
|
||
}
|
||
}
|
||
|
||
if let error = saveError {
|
||
Section {
|
||
Text(error).foregroundStyle(.red).font(.footnote)
|
||
}
|
||
}
|
||
|
||
Section {
|
||
Button {
|
||
Task { await saveAll() }
|
||
} label: {
|
||
if isSavingAll {
|
||
HStack {
|
||
ProgressView().scaleEffect(0.8)
|
||
Text("Saving \(savedCount)/\(viewModel.scannedItems.count)…")
|
||
}
|
||
.frame(maxWidth: .infinity)
|
||
} else {
|
||
Text("Save All to Inventory")
|
||
.fontWeight(.semibold)
|
||
.frame(maxWidth: .infinity)
|
||
}
|
||
}
|
||
.buttonStyle(.borderedProminent)
|
||
.tint(Color(.brandPrimary))
|
||
.disabled(viewModel.scannedItems.isEmpty || isSavingAll)
|
||
}
|
||
}
|
||
.navigationTitle("Review Scans")
|
||
.navigationBarTitleDisplayMode(.inline)
|
||
.toolbar {
|
||
ToolbarItem(placement: .topBarLeading) {
|
||
Button("Back") {
|
||
viewModel.showReview = false
|
||
}
|
||
}
|
||
}
|
||
}
|
||
.sheet(item: $editingItem) { item in
|
||
ScannedItemEditView(
|
||
item: item,
|
||
piFirstName: viewModel.piFirstName,
|
||
bldgCode: viewModel.bldgCode,
|
||
lab: viewModel.lab,
|
||
storageLocation: viewModel.storageLocation,
|
||
contact: viewModel.contact
|
||
) { updated in
|
||
if let idx = viewModel.scannedItems.firstIndex(where: { $0.id == updated.id }) {
|
||
viewModel.scannedItems[idx] = updated
|
||
}
|
||
editingItem = nil
|
||
}
|
||
}
|
||
}
|
||
|
||
private func saveAll() async {
|
||
isSavingAll = true
|
||
saveError = nil
|
||
savedCount = 0
|
||
var failed = 0
|
||
|
||
for item in viewModel.scannedItems {
|
||
let body = ChemicalCreateBody(
|
||
piFirstName: viewModel.piFirstName.isEmpty ? "Unknown" : viewModel.piFirstName,
|
||
physicalState: item.physicalState.isEmpty ? "Solid" : item.physicalState,
|
||
chemicalName: item.chemicalName.isEmpty ? "Unknown Chemical" : item.chemicalName,
|
||
bldgCode: viewModel.bldgCode.isEmpty ? "Unknown" : viewModel.bldgCode,
|
||
lab: viewModel.lab.isEmpty ? "Unknown" : viewModel.lab,
|
||
storageLocation: viewModel.storageLocation.isEmpty ? "Unknown" : viewModel.storageLocation,
|
||
storageDevice: item.storageDevice,
|
||
numberOfContainers: "1",
|
||
amountPerContainer: item.amountPerContainer.isEmpty ? "Unknown" : item.amountPerContainer,
|
||
unitOfMeasure: item.unitOfMeasure.isEmpty ? "Unknown" : item.unitOfMeasure,
|
||
casNumber: item.casNumber.isEmpty ? "Unknown" : item.casNumber,
|
||
chemicalFormula: item.chemicalFormula.isEmpty ? nil : item.chemicalFormula,
|
||
molecularWeight: item.molecularWeight.isEmpty ? nil : item.molecularWeight,
|
||
vendor: item.vendor.isEmpty ? nil : item.vendor,
|
||
catalogNumber: item.catalogNumber.isEmpty ? nil : item.catalogNumber,
|
||
lotNumber: item.lotNumber.isEmpty ? nil : item.lotNumber,
|
||
expirationDate: item.expirationDate.isEmpty ? nil : item.expirationDate,
|
||
concentration: item.concentration.isEmpty ? nil : item.concentration,
|
||
percentageFull: item.percentageFull,
|
||
barcode: item.barcode,
|
||
contact: viewModel.contact.isEmpty ? nil : viewModel.contact
|
||
)
|
||
do {
|
||
_ = try await chemicalsClient.create(body)
|
||
savedCount += 1
|
||
} catch {
|
||
failed += 1
|
||
}
|
||
}
|
||
|
||
isSavingAll = false
|
||
if failed > 0 {
|
||
saveError = "\(failed) item(s) failed to save. The rest were saved successfully."
|
||
} else {
|
||
onDone()
|
||
}
|
||
}
|
||
}
|
||
|
||
// MARK: - Scanned item row (review list)
|
||
|
||
private struct ScannedItemRow: View {
|
||
let item: ScannedItem
|
||
|
||
var body: some View {
|
||
HStack(spacing: 12) {
|
||
if let thumb = item.thumbnail {
|
||
Image(uiImage: thumb)
|
||
.resizable()
|
||
.scaledToFill()
|
||
.frame(width: 52, height: 52)
|
||
.clipShape(RoundedRectangle(cornerRadius: 8))
|
||
} else {
|
||
RoundedRectangle(cornerRadius: 8)
|
||
.fill(Color.secondary.opacity(0.15))
|
||
.frame(width: 52, height: 52)
|
||
.overlay {
|
||
Image(systemName: "flask.fill")
|
||
.foregroundStyle(.secondary)
|
||
}
|
||
}
|
||
VStack(alignment: .leading, spacing: 3) {
|
||
Text(item.chemicalName.isEmpty ? "Unnamed chemical" : item.chemicalName)
|
||
.font(.subheadline.weight(.semibold))
|
||
.lineLimit(1)
|
||
HStack(spacing: 6) {
|
||
if !item.casNumber.isEmpty {
|
||
Text("CAS: \(item.casNumber)").font(.caption).foregroundStyle(.secondary)
|
||
}
|
||
if !item.vendor.isEmpty {
|
||
Text("· \(item.vendor)").font(.caption).foregroundStyle(.secondary)
|
||
}
|
||
}
|
||
HStack(spacing: 6) {
|
||
if !item.amountPerContainer.isEmpty {
|
||
Text("\(item.amountPerContainer) \(item.unitOfMeasure)").font(.caption2).foregroundStyle(.secondary)
|
||
}
|
||
Text("· \(Int(item.percentageFull))% full").font(.caption2).foregroundStyle(.secondary)
|
||
}
|
||
}
|
||
Spacer()
|
||
Image(systemName: "chevron.right")
|
||
.font(.caption)
|
||
.foregroundStyle(.tertiary)
|
||
}
|
||
.padding(.vertical, 4)
|
||
}
|
||
}
|
||
|
||
// MARK: - Edit a single scanned item
|
||
|
||
struct ScannedItemEditView: View {
|
||
@State private var item: ScannedItem
|
||
@State private var piFirstName: String
|
||
@State private var bldgCode: String
|
||
@State private var lab: String
|
||
@State private var storageLocation: String
|
||
@State private var contact: String
|
||
let onSave: (ScannedItem) -> Void
|
||
|
||
init(item: ScannedItem, piFirstName: String, bldgCode: String, lab: String,
|
||
storageLocation: String, contact: String, onSave: @escaping (ScannedItem) -> Void) {
|
||
_item = State(initialValue: item)
|
||
_piFirstName = State(initialValue: piFirstName)
|
||
_bldgCode = State(initialValue: bldgCode)
|
||
_lab = State(initialValue: lab)
|
||
_storageLocation = State(initialValue: storageLocation)
|
||
_contact = State(initialValue: contact)
|
||
self.onSave = onSave
|
||
}
|
||
|
||
var body: some View {
|
||
NavigationStack {
|
||
Form {
|
||
Section("Identity") {
|
||
LabeledTextField("Chemical Name", text: $item.chemicalName)
|
||
LabeledTextField("CAS #", text: $item.casNumber)
|
||
Picker("Physical State", selection: $item.physicalState) {
|
||
Text("Select…").tag("")
|
||
ForEach(["Solid","Liquid","Gas"], id: \.self) { Text($0).tag($0) }
|
||
}
|
||
Picker("Storage Device", selection: $item.storageDevice) {
|
||
ForEach(AddChemicalViewModel.storageDevices, id: \.self) { Text($0).tag($0) }
|
||
}
|
||
}
|
||
Section("Location") {
|
||
LabeledTextField("PI First Name", text: $piFirstName)
|
||
LabeledTextField("Building Code", text: $bldgCode)
|
||
LabeledTextField("Lab", text: $lab)
|
||
LabeledTextField("Storage Location", text: $storageLocation)
|
||
}
|
||
Section("Quantity") {
|
||
LabeledTextField("Amount / Container", text: $item.amountPerContainer)
|
||
LabeledTextField("Unit of Measure", text: $item.unitOfMeasure)
|
||
HStack {
|
||
Text("Fill Level")
|
||
Spacer()
|
||
Text("\(Int(item.percentageFull))%")
|
||
.foregroundStyle(.secondary)
|
||
}
|
||
Slider(value: $item.percentageFull, in: 0...100, step: 5)
|
||
.tint(Color(.brandPrimary))
|
||
}
|
||
Section("Details") {
|
||
LabeledTextField("Formula", text: $item.chemicalFormula)
|
||
LabeledTextField("MW", text: $item.molecularWeight)
|
||
LabeledTextField("Vendor", text: $item.vendor)
|
||
LabeledTextField("Catalog #", text: $item.catalogNumber)
|
||
LabeledTextField("Lot #", text: $item.lotNumber)
|
||
LabeledTextField("Expiration", text: $item.expirationDate)
|
||
LabeledTextField("Concentration", text: $item.concentration)
|
||
}
|
||
}
|
||
.navigationTitle("Edit Item")
|
||
.navigationBarTitleDisplayMode(.inline)
|
||
.toolbar {
|
||
ToolbarItem(placement: .topBarTrailing) {
|
||
Button("Save") {
|
||
var updated = item
|
||
updated.percentageFull = item.percentageFull
|
||
onSave(updated)
|
||
}
|
||
.fontWeight(.semibold)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
private struct LabeledTextField: View {
|
||
let label: String
|
||
@Binding var text: String
|
||
init(_ label: String, text: Binding<String>) {
|
||
self.label = label
|
||
self._text = text
|
||
}
|
||
var body: some View {
|
||
HStack {
|
||
Text(label).foregroundStyle(Color(UIColor.label))
|
||
Spacer(minLength: 8)
|
||
TextField(label, text: $text)
|
||
.multilineTextAlignment(.trailing)
|
||
.foregroundStyle(Color(UIColor.secondaryLabel))
|
||
}
|
||
}
|
||
}
|