ProfessionMaster.lua

--[[

@author Kurki
@copyright ©2026 Profession Master. All Rights Reserved.

--]] 

-- define addon name
local addonName = "Profession Master";
local addonVersion = C_AddOns.GetAddOnMetadata("ProfessionMaster", "version");
local addonShortcut = "|cffDA8CFF[PM]|r ";

-- define addon
ProfessionMasterAddon = {};
ProfessionMasterAddon.__index = ProfessionMasterAddon;

-- prepare storage
if (not PM_OwnProfessions) then PM_OwnProfessions = {}; end
if (not PM_Professions) then PM_Professions = {}; end
if (not PM_SyncTimes) then PM_SyncTimes = {}; end
if (not PM_Logs) then PM_Logs = {}; end
if (not PM_CharacterSets) then PM_CharacterSets = {}; end
if (not PM_BucketList) then PM_BucketList = {}; end
if (not PM_ReagentWatchList) then PM_ReagentWatchList = {}; end
if (not PM_CharacterSettings) then PM_CharacterSettings = {}; end
if (not PM_Guildmates) then PM_Guildmates = {}; end
if (not PM_PlayerFactions) then PM_PlayerFactions = {}; end
if (not PM_Specializations) then PM_Specializations = {}; end
if (not PM_Skills) then PM_Skills = {}; end

--- Create new addon container.
function ProfessionMasterAddon:Create()
    -- get wow build
    local wowBuild = GetBuildInfo();

    -- create addon and add empty holders
    local addon = {
        name = addonName,
        version = addonVersion,
        shortcut = addonShortcut,
        frame = CreateFrame("Frame"),
        loaded = false,
        isVanilla = string.find(wowBuild, "1.") == 1,
        isBcc = string.find(wowBuild, "2.") == 1,
        isWrath = string.find(wowBuild, "3.") == 1,
        isCata = string.find(wowBuild, "4.") == 1,
        isMop = string.find(wowBuild, "5.") == 1,
    };
    setmetatable(addon, ProfessionMasterAddon);
    
    -- set at least addon indicators
    addon.isMopAtLeast = addon.isMop;
    addon.isCataAtLeast = addon.isCata or addon.isMopAtLeast;
    addon.isWrathAtLeast = addon.isWrath or addon.isCataAtLeast;
    addon.isBccAtLeast = addon.isBcc or addon.isWrathAtLeast;

    -- clear types
    addon.serviceTypes = {};
    addon.services = {};
    addon.viewTypes = {};
    addon.modelTypes = {};
    addon.eventHandlers = {};

    -- register events
    addon:RegisterEvents();
    return addon;
end

--- Create service.
-- @param name Name of service.
-- @return Service type definition.
function ProfessionMasterAddon:CreateService(name)
    local serviceType = {};
    serviceType.__index = serviceType;
    self.serviceTypes[name] = serviceType;
    return serviceType;
end

--- Check settings.
function ProfessionMasterAddon:CheckSettings()
    -- check settings
    if (not PM_Settings) then 
        PM_Settings = {}; 
    end
    if (not PM_Settings.storageId) then
        PM_Settings.storageId = self:GenerateString(12);
    end
    if (not PM_Settings.minimapButton) then
        PM_Settings.minimapButton = {
            hide = false
        };
    end
    if (PM_Settings.respondToWho == nil) then
        PM_Settings.respondToWho = true;
    end
    if (PM_Settings.sendNonGuildCharacters == nil) then
        PM_Settings.sendNonGuildCharacters = true;
    end
end

--- Create view.
-- @param name Name of view.
-- @return View type definition.
function ProfessionMasterAddon:CreateView(name)
    local viewType = {};
    viewType.__index = viewType;
    self.viewTypes[name] = viewType;
    return viewType;
end

--- Create model.
-- @param name Name of model.
-- @param initialData Optional initial data table for data-only models.
-- @return Model type definition.
function ProfessionMasterAddon:CreateModel(name, initialData)
    local modelType;
    if (initialData) then
        -- data model: store as-is, no injection
        modelType = initialData;
    else
        -- class model: inject helpers
        modelType = {
            addon = self,
            GetService = function(_self, serviceName)
                return self:GetService(serviceName);
            end,
            GetModel = function(_self, modelName)
                return self:GetModel(modelName);
            end,
        };
        modelType.__index = modelType;
    end
    self.modelTypes[name] = modelType;
    return modelType;
end

--- Get service.
-- @param name Name of service.
function ProfessionMasterAddon:GetService(name)
    -- check if service created
    if (self.services[name] == nil) then
        -- create service with injected helpers
        local service = {
            addon = self,
            GetService = function(_self, serviceName)
                return self:GetService(serviceName);
            end,
            GetModel = function(_self, modelName)
                return self:GetModel(modelName);
            end,
            HandleEvent = function(_self, eventName, callback)
                return self:HandleEvent(eventName, callback);
            end
        };
        setmetatable(service, self.serviceTypes[name]);
        self.services[name] = service;

        -- initialize service
        if (service.Initialize) then
            service:Initialize();
        end
    end

    -- get service
    return self.services[name];
end

--- Create new view instance.
-- @param name Name of view.
function ProfessionMasterAddon:NewView(name)
    -- get view type
    local viewType = self.viewTypes[name];

    -- create view with injected helpers
    local view = {
        addon = self,
        GetService = function(_self, serviceName)
            return self:GetService(serviceName);
        end,
        GetModel = function(_self, modelName)
            return self:GetModel(modelName);
        end
    };
    setmetatable(view, viewType);
    return view;
end

--- Get model.
-- @param name Name of model.
function ProfessionMasterAddon:GetModel(name)
    -- get model type
    return self.modelTypes[name];
end

--- Log a message.
-- @param class Name of class to log within.
-- @param method Name of method to log within.
-- @param message Log message.
function ProfessionMasterAddon:Log(class, method, message, ...)
    self:GetService("log"):AddEntry(class .. ":" .. method .. " - " .. string.format(message, ...));
end

--- Handle event.
-- @param name Event name.
-- @param callback Callback function, triggered on event.
function ProfessionMasterAddon:HandleEvent(name, callback)
    -- check if event not handled before
    if (self.eventHandlers[name] == nil) then
        -- create event handler array for the given event name
        self.eventHandlers[name] = {};

        -- watch event
        self.frame:RegisterEvent(name);
    end

    -- add callback to event handler
    table.insert(self.eventHandlers[name], callback);
end

--- Register addon events.
function ProfessionMasterAddon:RegisterEvents()
    -- handle on event
    self.frame:SetScript("OnEvent", function(_self, event, ...)
        -- dispatch to registered handlers
        if (self.eventHandlers[event]) then
            for _, handler in ipairs(self.eventHandlers[event]) do
                handler(...);
            end
        end
    end);

    -- handle addon loaded
    self:HandleEvent("ADDON_LOADED", function(addonName)
        if (addonName == "ProfessionMaster") then
            self:CheckSettings();
            self:GetService("commands");
        end
    end);

    -- handle chat message
    self:HandleEvent("CHAT_MSG_ADDON", function(prefix, message, channel, sender)
        self:GetService("message"):HandleMessage(prefix, message, sender);
    end);

    -- handle login
    self:HandleEvent("PLAYER_LOGIN", function()
        self.frame:UnregisterEvent("PLAYER_LOGIN");

        -- create professions view
        self.professionsView = self:NewView("professions");

        -- migrate data
        self:Migrate();

        -- create minimap icon
        self:GetService("ui"):CreateMinimapIcon();

        -- initialize settings panel
        self.settingsView = self:NewView("settings");
        self.settingsView:Initialize();

        -- watch tooltip
        self:GetService("tooltip"):WatchTooltip();

        -- startup
        self:GetService("timer"):Wait("PlayerLogin", 5, function()
            -- show loaded message
            self:GetService("chat"):Write("AddonLoaded");

            -- broadcast version
            self:GetService("message"):SendToGuild(self:GetModel("version-broadcast-message"):Create());

            -- check welcome
            self:GetService("own-professions"):CheckWelcome();

            -- detect own specializations (TBC+)
            self:GetService("own-professions"):DetectSpecializations();

            -- say hello to guild
            self:GetService("professions"):SayHelloToGuild();

            -- check missing reagents
            self:GetService("inventory"):CheckMissingReagents();
        end);
    end);

    -- handle trade skill update
    self:HandleEvent("TRADE_SKILL_UPDATE", function()
        self:GetService("own-professions"):GetProfessionData();
    end);

    -- handle craft update
    self:HandleEvent("CRAFT_UPDATE", function()
        self:GetService("own-professions"):GetProfessionData();
    end);

    -- handle guild roster update
    self:HandleEvent("GUILD_ROSTER_UPDATE", function()
        self:GetService("player"):RefreshGuildmates();
    end);

    -- handle combat enter
    self:HandleEvent("PLAYER_REGEN_DISABLED", function()
        self.inCombat = true;
        if (self.professionsView and self.professionsView.visible) then
            self.professionsView:Hide();
        end
    end);

    -- handle combat leave
    self:HandleEvent("PLAYER_REGEN_ENABLED", function()
        self.inCombat = nil;
    end);

    -- handle bag update (debounced)
    self:HandleEvent("BAG_UPDATE", function()
        -- immediately invalidate inventory cache
        self:GetService("inventory"):InvalidateInventory();

        -- debounce the actual reagent check
        if (not self.bagUpdatePending) then
            self.bagUpdatePending = true;
            C_Timer.After(0.2, function()
                self.bagUpdatePending = nil;
                self:GetService("inventory"):CheckMissingReagents();
            end);
        end
    end);
end

-- prepare charset
local idCharset = {};
for i = 48, 57 do
    table.insert(idCharset, string.char(i))
end
for i = 65, 90 do
    table.insert(idCharset, string.char(i))
end
for i = 97, 122 do
    table.insert(idCharset, string.char(i))
end

-- Generate random string.
function ProfessionMasterAddon:GenerateString(length)
    -- build id
    local id = {};
    for i = 1, length do
        table.insert(id, idCharset[math.random(1, #idCharset)]);
    end
    return table.concat(id, "");
end

-- Migrate saved variable from old unprefixed name to new PM_ prefixed name.
local function MigrateSavedVariable(oldName, newName)
    if (_G[oldName] ~= nil) then
        _G[newName] = _G[oldName];
    end
    _G[oldName] = nil;
end

-- Migrate data.
function ProfessionMasterAddon:Migrate()
    -- get store version from new or old settings
    local storeVersion = PM_Settings.storeVersion or (PMSettings and PMSettings.storeVersion);

    -- migrate from pre-7 saved variable names (only if old version exists)
    if (storeVersion and storeVersion < 7) then
        MigrateSavedVariable("Professions", "PM_Professions");
        MigrateSavedVariable("OwnProfessions", "PM_OwnProfessions");
        MigrateSavedVariable("SyncTimes", "PM_SyncTimes");
        MigrateSavedVariable("PMSettings", "PM_Settings");
        MigrateSavedVariable("Logs", "PM_Logs");
        MigrateSavedVariable("CharacterSets", "PM_CharacterSets");
        MigrateSavedVariable("BucketList", "PM_BucketList");
        MigrateSavedVariable("ReagentWatchList", "PM_ReagentWatchList");
        MigrateSavedVariable("CharacterSettings", "PM_CharacterSettings");
        MigrateSavedVariable("Guildmates", "PM_Guildmates");
        MigrateSavedVariable("Convert", "PM_Convert");
        MigrateSavedVariable("PlayerFactions", "PM_PlayerFactions");
        MigrateSavedVariable("Frames", "PM_Frames");
    end

    -- set store version
    PM_Settings.storeVersion = 7;
end

-- create addon
_G.professionMaster = ProfessionMasterAddon:Create();