path: root/Map/Business/Stage.swift

// Copyright (C) 2024 Rubén Beltrán del Río

// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program. If not, see https://map.tranquil.systems.
import SwiftUI

struct Stage: Codable {
  var i: String
  var ii: String
  var iii: String
  var iv: String

  static func stages(_ type: StageType) -> Stage {
    switch type {
    case .general:
      return Stage(
        i: "Genesis", ii: "Custom", iii: "Product (+rental)", iv: "Commodity (+utility)")
    case .practice:
      return Stage(
        i: "Novel", ii: "Emerging", iii: "Good", iv: "Best")
    case .data:
      return Stage(
        i: "Unmodelled", ii: "Divergent", iii: "Convergent", iv: "Modelled")
    case .knowledge:
      return Stage(
        i: "Concept", ii: "Hypothesis", iii: "Theory", iv: "Accepted")
    case .ubiquity:
      return Stage(
        i: "Rare", ii: "Slowly Increasing", iii: "Rapidly Increasing",
        iv: "Widespread in the applicable market / ecosystem")
    case .certainty:
      return Stage(
        i: "Poorly Understood / exploring the unknown",
        ii: "Rapid Increase In Learning / discovery becomes refining",
        iii: "Rapid increase in use / increasing fit for purpose",
        iv: "Commonly understood (in terms of use)")
    case .publicationTypes:
      return Stage(
        i:
          "Describe the wonder of the thing / the discovery of some marvel / a new land / an unknown frontier",
        ii:
          "Focused on build / construct / awareness and learning / many models of explanation / no accepted forms / a wild west",
        iii:
          "Maintenance / operations / installation / comparison between competing forms / feature analysis",
        iv: "Focused on use / increasingly an accepted, almost invisible component")
    case .market:
      return Stage(
        i: "Undefined Market",
        ii: "Forming Market / an array of competing forms and models of understanding",
        iii: "Growing Market / consolidation to a few competing but more accepted forms",
        iv: "Mature Market / stabilised to an accepted form")
    case .knowledgeManagement:
      return Stage(
        i: "Uncertain", ii: "Learning on use / focused on testing prediction",
        iii: "Learning on operation / using prediction / verification", iv: "Known / accepted")
    case .marketPerception:
      return Stage(
        i: "Chaotic (non-linear) / domain of the \"crazy\"", ii: "Domain of \"experts\"",
        iii: "Increasing expectation of use / domain of \"professionals\"",
        iv: "Ordered (appearance of being linear) / trivial / formula to be applied")
    case .userPerception:
      return Stage(
        i: "Different / confusing / exciting / surprising / dangerous",
        ii: "Leading edge / emerging / unceirtanty over results",
        iii: "Increasingly common / disappointed if not used or available / feeling left behind",
        iv: "Standard / expected / feeling of shock if not used")
    case .perceptionInIndustry:
      return Stage(
        i: "Future source of competitive advantage / unpredictable / unknown",
        ii: "Seen as a scompetitive advantage / a differential / ROI / case examples",
        iii: "Advantage through implementation / features / this model is better than that",
        iv: "Cost of doing business / accepted / specific defined models")
    case .focusOfValue:
      return Stage(
        i: "High future worth but immediate investment",
        ii: "Seeking ways to profit and a ROI / seeking confirmation of value",
        iii:
          "High profitability per unit / a valuable model / a feeling of understanding / focus on exploitation",
        iv:
          "High volume / reducing margin / important but invisible / an essential component of something more complex"
      )
    case .understanding:
      return Stage(
        i: "Poorly Understood / unpredictable",
        ii: "Increasing understanding / development of measures",
        iii: "Increasing education / constant refinement of needs / measures",
        iv: "Believed to be well defined / stable / measurable")
    case .comparison:
      return Stage(
        i: "Constantly changing / a differential / unstable",
        ii: "Learning from others / testing the water / some evidential support",
        iii: "Competing models / feature difference / evidential support",
        iv: "Essential / any advantage is operational / accepted norm")
    case .failure:
      return Stage(
        i: "High / tolerated / assumed to be wrong",
        ii: "Moderate / unsurprising if wrong but disappointed",
        iii:
          "Not tolerated / focus on constant improvement / assumed to be in the right direction / resistance to changing the model",
        iv: "Surprised by failure / focus on operational efficiency")
    case .marketAction:
      return Stage(
        i: "Gambling / driven by gut", ii: "Exploring a \"found\" value",
        iii: "Market analysis / listening to customers", iv: "Metric driven / build what is needed")
    case .efficiency:
      return Stage(
        i: "Reducing the cost of change (experimentation)", ii: "Reducing cost of waste (Learning)",
        iii: "Reducing cost of waste (Learning)", iv: "Reducing cost of deviation (Volume)")
    case .decisionDrivers:
      return Stage(
        i: "Heritage / culture", ii: "Analyses & synthesis", iii: "Analyses & synthesis",
        iv: "Previous Experience")
    case .behavior:
      return Stage(
        i: "Uncertain when to use", ii: "Learning when to use", iii: "Learning through use",
        iv: "Known / common usage")
    case .custom(let uuid):
      if let customStagesData = UserDefaults.standard.data(forKey: "customStages"),
        let customStagesList = try? JSONDecoder().decode(
          [CustomStage].self, from: customStagesData),
        let customStage = customStagesList.first(where: { $0.id == uuid })
      {
        return customStage.stage
      }
      return stages(.behavior)  // fallback
    }
  }

  static func title(_ type: StageType) -> String {
    switch type {
    case .general:
      return String(localized: "stage_type.general")
    case .practice:
      return String(localized: "stage_type.practice")
    case .data:
      return String(localized: "stage_type.data")
    case .knowledge:
      return String(localized: "stage_type.knowledge")
    case .ubiquity:
      return String(localized: "stage_type.ubiquity")
    case .certainty:
      return String(localized: "stage_type.certainty")
    case .publicationTypes:
      return String(localized: "stage_type.publication_types")
    case .market:
      return String(localized: "stage_type.market")
    case .knowledgeManagement:
      return String(localized: "stage_type.knowledge_management")
    case .marketPerception:
      return String(localized: "stage_type.market_perception")
    case .userPerception:
      return String(localized: "stage_type.user_perception")
    case .perceptionInIndustry:
      return String(localized: "stage_type.perception_in_industry")
    case .focusOfValue:
      return String(localized: "stage_type.focus_of_value")
    case .understanding:
      return String(localized: "stage_type.understanding")
    case .comparison:
      return String(localized: "stage_type.comparison")
    case .failure:
      return String(localized: "stage_type.failure")
    case .marketAction:
      return String(localized: "stage_type.market_action")
    case .efficiency:
      return String(localized: "stage_type.efficiency")
    case .decisionDrivers:
      return String(localized: "stage_type.decision_drivers")
    case .behavior:
      return String(localized: "stage_type.behavior")
    case .custom(let uuid):
      if let customStagesData = UserDefaults.standard.data(forKey: "customStages"),
        let customStagesList = try? JSONDecoder().decode(
          [CustomStage].self, from: customStagesData),
        let customStage = customStagesList.first(where: { $0.id == uuid })
      {
        return customStage.name
      }
      return String(localized: "stage_type.behavior")  // fallback
    }
  }
}

enum StageType: Identifiable, Equatable {
  case general
  case practice
  case data
  case knowledge

  case ubiquity
  case certainty
  case publicationTypes

  case market
  case knowledgeManagement
  case marketPerception
  case userPerception
  case perceptionInIndustry
  case focusOfValue
  case understanding
  case comparison
  case failure
  case marketAction
  case efficiency
  case decisionDrivers

  case behavior
  case custom(UUID)

  var id: String {
    switch self {
    case .general: return "general"
    case .practice: return "practice"
    case .data: return "data"
    case .knowledge: return "knowledge"
    case .ubiquity: return "ubiquity"
    case .certainty: return "certainty"
    case .publicationTypes: return "publicationTypes"
    case .market: return "market"
    case .knowledgeManagement: return "knowledgeManagement"
    case .marketPerception: return "marketPerception"
    case .userPerception: return "userPerception"
    case .perceptionInIndustry: return "perceptionInIndustry"
    case .focusOfValue: return "focusOfValue"
    case .understanding: return "understanding"
    case .comparison: return "comparison"
    case .failure: return "failure"
    case .marketAction: return "marketAction"
    case .efficiency: return "efficiency"
    case .decisionDrivers: return "decisionDrivers"
    case .behavior: return "behavior"
    case .custom(let uuid): return uuid.uuidString.lowercased()
    }
  }

  static let types: [StageType] = [.general, .practice, .data, .knowledge]
  static let characteristics: [StageType] = [.ubiquity, .certainty, .publicationTypes]
  static let properties: [StageType] = [
    .market, .knowledgeManagement, .marketPerception, .userPerception,
    .perceptionInIndustry, .focusOfValue, .understanding, .comparison, .failure,
    .marketAction, .efficiency, .decisionDrivers,
  ]

  static var customStages: [StageType] {
    if let customStagesData = UserDefaults.standard.data(forKey: "customStages"),
      let customStagesList = try? JSONDecoder().decode([CustomStage].self, from: customStagesData)
    {
      return customStagesList.map { .custom($0.id) }
    }
    return []
  }
}