package.path = package.path .. ";data/scripts/lib/?.lua"

TurretFactory = TurretFactory or {}
local Config = include("elonturretfactoryconfig")
if onClient() then
    TurretFactory.UI = {}
    TurretFactory.UI.lines = {}
    TurretFactory.UI.stat_lines = {}
    TurretFactory.UI.seed_index = 1
    TurretFactory.UI.size = Config.ui_size or vec2(1050, 500)
    TurretFactory.UI.offset = Config.ui_offset or vec2(-185,0)
    TurretFactory.unsorted_Turret_List = {}
    TurretFactory.max_stats = {}
end

function TurretFactory.restore(data)
    TurretFactory.max_seed = data.maxSeedAmount
end

function TurretFactory.secure()
    local data = {}
    data.maxSeedAmount = TurretFactory.max_seed
    return data
end

function TurretFactory.initUI() -- Overriding vanilla

    local res = getResolution()

    TurretFactory.UI.menu = ScriptUI()
    TurretFactory.UI.window = TurretFactory.UI.menu:createWindow(Rect(res * 0.5 - TurretFactory.UI.size * 0.5 + TurretFactory.UI.offset, res * 0.5 + TurretFactory.UI.size * 0.5 + TurretFactory.UI.offset))

    TurretFactory.UI.window.caption = "Turret Factory"%_t
    TurretFactory.UI.window.showCloseButton = 1
    TurretFactory.UI.window.moveable = 1
    TurretFactory.UI.menu:registerWindow(TurretFactory.UI.window, "Build Turrets /*window title*/"%_t);

    TurretFactory.UI.container = TurretFactory.UI.window:createContainer(Rect(vec2(0,0), TurretFactory.UI.size));

    TurretFactory.UI.horizontal_lister = UIHorizontalLister(Rect(vec2(0,10), TurretFactory.UI.size+vec2(0,-10)),10,10)

    --left
    TurretFactory.UI.left = UIHorizontalSplitter(TurretFactory.UI.horizontal_lister:placeCenter(vec2(TurretFactory.UI.size.x/4-10, TurretFactory.UI.size.y-20)),10,0,0.82)
    TurretFactory.UI.container:createFrame(TurretFactory.UI.left.top);
    TurretFactory.UI.container:createFrame(TurretFactory.UI.left.bottom);

    TurretFactory.UI.left_lister = UIVerticalLister(TurretFactory.UI.left.top, 10, 10)
    TurretFactory.UI.left_lister.padding = 10 -- add a higher padding as the slider texts might overlap otherwise

    TurretFactory.UI.container:createLabel(TurretFactory.UI.left_lister:placeCenter(vec2(TurretFactory.UI.left_lister.inner.width, 15)).lower, "Weapon Type"%_t, 14)
    TurretFactory.UI.turretTypeCombo = TurretFactory.UI.container:createComboBox(Rect(), "onTurretTypeSelect")
    TurretFactory.UI.left_lister:placeElementCenter(TurretFactory.UI.turretTypeCombo)

    TurretFactory.UI.container:createLabel(TurretFactory.UI.left_lister:placeCenter(vec2(TurretFactory.UI.left_lister.inner.width, 15)).lower, "Rarity"%_t, 14)
    TurretFactory.UI.rarityCombo = TurretFactory.UI.container:createComboBox(Rect(), "onRaritySelect")
    TurretFactory.UI.left_lister:placeElementCenter(TurretFactory.UI.rarityCombo)

    TurretFactory.UI.rarityCombo:addEntry("Common"%_t, Rarity(RarityType.Common).color)
    TurretFactory.UI.rarityCombo:addEntry("Uncommon"%_t, Rarity(RarityType.Uncommon).color)
    TurretFactory.UI.rarityCombo:addEntry("Rare"%_t, Rarity(RarityType.Rare).color)

    TurretFactory.UI.container:createLabel(TurretFactory.UI.left_lister:placeCenter(vec2(TurretFactory.UI.left_lister.inner.width, 15)).lower, "Crafting Amount"%_t, 14)
    TurretFactory.UI.bulkTextBox = TurretFactory.UI.container:createTextBox(TurretFactory.UI.left_lister:placeCenter(vec2(TurretFactory.UI.left_lister.inner.width, 30)), "bulkChanged");
    TurretFactory.UI.bulkTextBox.text = TurretFactory.bulk or 1
    TurretFactory.UI.bulkTextBox.allowedCharacters = "0123456789"

    TurretFactory.UI.help_checkbox = TurretFactory.UI.container:createCheckBox(Rect(TurretFactory.UI.left.top.topRight+vec2(-75-10,10),TurretFactory.UI.left.top.topRight+vec2(-10,20+10)),"Help?","onHelp")

    TurretFactory.UI.help_text_field_rect = TurretFactory.UI.left_lister:placeCenter(vec2(TurretFactory.UI.left_lister.inner.width, 180))
    TurretFactory.UI.container:createFrame(TurretFactory.UI.help_text_field_rect)
    TurretFactory.UI.help_text_field = TurretFactory.UI.container:createTextField(TurretFactory.UI.help_text_field_rect,"",14)
    TurretFactory.UI.help_text_field.text = "To use the search feature check a box for the stat you want included in the sum. The turret factory will then find the max value for every box checked and measure every turrets stat against its max to determine a value out of 1. That number is added to the turrets \"sum\" which is used when sorting turrets. You can invert the value before its added to the sum by adding a \"!\". \n \nThe text box to the right of the stat is used not only for inverting its value as mentioned above but also for punishing turrets for not meeting at-least the value you put inside that box. Putting a \"-\" in will flip that to be at-most instead of at-least. \n\nIt is worth mentioning the ingredients used to make affect the search, so you probably want to check the max box before a search."

    TurretFactory.UI.left_horizontal_split = UIHorizontalSplitter(TurretFactory.UI.left.bottom,10,10,0.5)

    TurretFactory.UI.left_seed_label_top = TurretFactory.UI.container:createLabel(TurretFactory.UI.left_horizontal_split.top.topLeft+vec2(0,-5),"",14)
    TurretFactory.UI.left_seed_label_bottom = TurretFactory.UI.container:createLabel(TurretFactory.UI.left_horizontal_split.top.bottomLeft+vec2(0,-15),"",14)

    if Config.seedsBuyable then

        TurretFactory.UI.left_seed_label_top.caption = "Buy more seeds:"
        TurretFactory.UI.left_seed_label_bottom.caption = "Currently Unlocked: 1"
        TurretFactory.UI.upgrade_button = TurretFactory.UI.container:createButton(TurretFactory.UI.left_horizontal_split.bottom,"Upgrade Seeds","onUpgrade")

    else

        TurretFactory.UI.left_seed_label_top.caption = "Search Start:"
        TurretFactory.UI.left_seed_label_bottom.caption = "From seed x to x+"..Config.sample_size
        TurretFactory.UI.left_seed_text_box = TurretFactory.UI.container:createTextBox(TurretFactory.UI.left_horizontal_split.bottom,"clearTurretList")
        TurretFactory.UI.left_seed_text_box.text = "0"
        TurretFactory.UI.left_seed_text_box.allowedCharacters = "0123456789"

    end

    --middle
    TurretFactory.UI.middle = UIHorizontalSplitter(TurretFactory.UI.horizontal_lister:placeCenter(vec2(TurretFactory.UI.size.x/4-10, TurretFactory.UI.size.y-20)),10,0,0.82)
    TurretFactory.UI.middle_scroll_frame = TurretFactory.UI.container:createScrollFrame(TurretFactory.UI.middle.top)
    TurretFactory.UI.middle_lister = UIVerticalLister(Rect(vec2(),TurretFactory.UI.middle.top.size+vec2(-15,0)),10,10)
    TurretFactory.UI.container:createFrame(TurretFactory.UI.middle.bottom);

    for _ = 1, 50 do

        local line = {}
        line.rect = TurretFactory.UI.middle_lister:placeCenter(vec2(TurretFactory.UI.middle_lister.inner.width, 20))
        line.vertical_split = UIArbitraryVerticalSplitter(line.rect, 10, 0, 25, TurretFactory.UI.middle_lister.inner.width/2+15, TurretFactory.UI.middle_lister.inner.width)

        local i = 0
        line.checkbox = TurretFactory.UI.middle_scroll_frame:createCheckBox(line.vertical_split:partition(i),"",""); i = i + 1
        line.stat_frame = TurretFactory.UI.middle_scroll_frame:createFrame(line.vertical_split:partition(i))
        line.stat_frame.backgroundColor = ColorARGB(0.7,0,0,0)
        line.stat = TurretFactory.UI.middle_scroll_frame:createLabel(line.vertical_split:partition(i).lower+vec2(2.5,2.5), "Stat", 14)
        line.stat.shortenText = true
        line.stat.size = line.vertical_split:partition(i).size; i = i + 1
        line.text_box = TurretFactory.UI.middle_scroll_frame:createTextBox(line.vertical_split:partition(i),"")
        line.text_box.text = 0
        line.text_box.allowedCharacters = "0123456789!.-"; i = i + 1

        line.hide = function(self)
            self.checkbox:hide()
            self.stat_frame:hide()
            self.stat:hide()
            self.text_box:hide()
        end

        line.show = function(self)
            self.checkbox:show()
            self.stat_frame:show()
            self.stat:show()
            self.text_box:show()
        end

        line:hide()

        table.insert(TurretFactory.UI.stat_lines,line)

    end

    TurretFactory.UI.middle_vertical_split = UIVerticalSplitter(TurretFactory.UI.middle.bottom,10,10,2/3)
    TurretFactory.UI.middle_clear_search = UIHorizontalSplitter(TurretFactory.UI.middle_vertical_split.right,10,0,0.5)
    TurretFactory.UI.clear_button = TurretFactory.UI.container:createButton(TurretFactory.UI.middle_clear_search.bottom, "Clear", "onClear")
    TurretFactory.UI.search_button = TurretFactory.UI.container:createButton(TurretFactory.UI.middle_clear_search.top, "Search", "onSearch")
    TurretFactory.UI.middle_seed_horizontal_split = UIHorizontalSplitter(TurretFactory.UI.middle_vertical_split.left,10,0,0.5)
    TurretFactory.UI.middle_seed_split = UIArbitraryVerticalSplitter(TurretFactory.UI.middle_seed_horizontal_split.bottom, 0, 0, TurretFactory.UI.middle_seed_horizontal_split.bottom.width/5, TurretFactory.UI.middle_seed_horizontal_split.bottom.width/5*4, TurretFactory.UI.middle_seed_horizontal_split.bottom.width)
    TurretFactory.UI.prev_button = TurretFactory.UI.container:createButton(TurretFactory.UI.middle_seed_split:partition(0),"<","onSeedPrev")
    TurretFactory.UI.seed_text_box = TurretFactory.UI.container:createTextBox(TurretFactory.UI.middle_seed_split:partition(1),"onSeedTextBox")
    TurretFactory.UI.seed_text_box.text = "0"
    TurretFactory.UI.seed_text_box.allowedCharacters = "0123456789"
    TurretFactory.UI.next_button = TurretFactory.UI.container:createButton(TurretFactory.UI.middle_seed_split:partition(2),">","onSeedNext")
    TurretFactory.UI.middle_seed_label_top = TurretFactory.UI.container:createLabel(TurretFactory.UI.middle_seed_horizontal_split.top.topLeft+vec2(0,-5), "Sum: 0", 14)
    TurretFactory.UI.middle_seed_label_top.size = TurretFactory.UI.middle_seed_horizontal_split.top.size
    TurretFactory.UI.middle_seed_label_top.shortenText = true
    TurretFactory.UI.middle_seed_label_bottom = TurretFactory.UI.container:createLabel(TurretFactory.UI.middle_seed_horizontal_split.top.bottomLeft+vec2(0,-15), "Current Seed:", 14)

    --right
    TurretFactory.UI.right = UIHorizontalSplitter(TurretFactory.UI.horizontal_lister:placeCenter(vec2(TurretFactory.UI.size.x/2-20, TurretFactory.UI.size.y-20)),10,0,0.82)
    TurretFactory.UI.right_scroll_frame = TurretFactory.UI.container:createScrollFrame(TurretFactory.UI.right.top)
    TurretFactory.UI.right_lister = UIVerticalLister(Rect(vec2(),TurretFactory.UI.right.top.size+vec2(-20,0)),10,10)
    TurretFactory.UI.container:createFrame(TurretFactory.UI.right.bottom);

    TurretFactory.UI.right_vertical_split = UIArbitraryVerticalSplitter(TurretFactory.UI.right_lister:placeCenter(vec2(TurretFactory.UI.right_lister.inner.width, 30)), 10, 5, 200, 240, 320, 390)
    TurretFactory.UI.parts_label = TurretFactory.UI.right_scroll_frame:createLabel(TurretFactory.UI.right_vertical_split:partition(0).lower, "Parts"%_t, 14)
    TurretFactory.UI.parts_label.size = TurretFactory.UI.right_vertical_split:partition(0).upper
    TurretFactory.UI.max_checkbox = TurretFactory.UI.right_scroll_frame:createCheckBox(TurretFactory.UI.right_vertical_split:partition(2),"Max","onMaxCheckBox")
    TurretFactory.UI.required_label = TurretFactory.UI.right_scroll_frame:createLabel(TurretFactory.UI.right_vertical_split:partition(3).lower, "Req"%_t, 14)
    TurretFactory.UI.required_label.size = vec2(50,30)
    TurretFactory.UI.you_label = TurretFactory.UI.right_scroll_frame:createLabel(TurretFactory.UI.right_vertical_split:partition(4).lower, "You"%_t, 14)
    TurretFactory.UI.you_label.size = vec2(50,30)
    TurretFactory.UI.parts_line = TurretFactory.UI.right_scroll_frame:createLine(vec2(10,40),vec2(TurretFactory.UI.right_lister.inner.width+10,40))

    for _ = 1, 20 do

        local line = {}
        line.rect = TurretFactory.UI.right_lister:placeCenter(vec2(TurretFactory.UI.right_lister.inner.width, 30))
        line.vertical_split = UIArbitraryVerticalSplitter(line.rect, 10, 7, 20, 250, 280, 310, 320, 390)

        line.frame = TurretFactory.UI.right_scroll_frame:createFrame(line.rect)

        local i = 0

        line.icon = TurretFactory.UI.right_scroll_frame:createPicture(line.vertical_split:partition(i), ""); i = i + 1
        line.material = TurretFactory.UI.right_scroll_frame:createLabel(line.vertical_split:partition(i).lower, "", 14)
        line.material.size = vec2(200,30); i = i + 1
        line.plus = TurretFactory.UI.right_scroll_frame:createButton(line.vertical_split:partition(i), "+", "onPlus"); i = i + 1
        line.minus = TurretFactory.UI.right_scroll_frame:createButton(line.vertical_split:partition(i), "-", "onMinus"); i = i + 2
        line.required = TurretFactory.UI.right_scroll_frame:createLabel(line.vertical_split:partition(i).lower, "", 14)
        line.required.size = vec2(50,30); i = i + 1
        line.you = TurretFactory.UI.right_scroll_frame:createLabel(line.vertical_split:partition(i).lower, "", 14)
        line.you.size = vec2(50,30); i = i + 1

        line.icon.isIcon = 1
        line.minus.textSize = 12
        line.plus.textSize = 12
        line.material.fontSize = 14
        line.required.fontSize = 14
        line.you.fontSize = 14

        line.hide = function(self)
            self.icon:hide()
            self.frame:hide()
            self.material:hide()
            self.plus:hide()
            self.minus:hide()
            self.required:hide()
            self.you:hide()
        end

        line.show = function(self)
            self.icon:show()
            self.frame:show()
            self.material:show()
            self.plus:show()
            self.minus:show()
            self.required:show()
            self.you:show()
        end

        line:hide()

        table.insert(TurretFactory.UI.lines, line)

    end

    TurretFactory.UI.buildButton = TurretFactory.UI.container:createButton(Rect(), "Build /*Turret Factory Button*/"%_t, "onBuildButtonPressed")
    TurretFactory.UI.right_organizer = UIOrganizer(TurretFactory.UI.right.bottom)
    TurretFactory.UI.right_organizer.margin = 10
    TurretFactory.UI.right_organizer:placeElementBottomRight(TurretFactory.UI.buildButton)

    TurretFactory.UI.priceLabel = TurretFactory.UI.container:createLabel(vec2(TurretFactory.UI.right.bottom.lower.x, TurretFactory.UI.right.bottom.upper.y) + vec2(12, -75), "Manufacturing Price: Too Much"%_t, 16)


    -- needs a separate counter here, weaponTypes are not strictly numbered from 1 to X
    local c = 0
    for _, type in pairs(weaponTypes) do
        local name = WeaponTypes.nameByType[type]

        TurretFactory.UI.turretTypeCombo:addEntry(name)
        weaponsByComboEntry[c] = type
        c = c + 1
    end

    TurretFactory.UI.turretTypeCombo.selectedIndex = 0

    -- Compatibility
    window = TurretFactory.UI.window
    container = TurretFactory.UI.container
    turretTypeCombo = TurretFactory.UI.turretTypeCombo
    rarityCombo = TurretFactory.UI.rarityCombo
    lines = TurretFactory.UI.lines
    priceLabel = TurretFactory.UI.priceLabel

end

function TurretFactory.refreshUI() -- Overriding vanilla
    local ingredients = TurretFactory.getUIIngredients()
    if Config.seedsBuyable then
        if not TurretFactory.max_seed then TurretFactory.syncMaxSeed() return end
        local price = (Config.upgradeBasePrice + (Config.upgradeBasePrice * 0.1 * TurretFactory.max_seed)) * Config.upgradeAmount
        if TurretFactory.max_seed + Config.upgradeAmount > Config.max_buyable then
            TurretFactory.UI.left_seed_label_top.caption = "You've bought all the seeds."
        else
            TurretFactory.UI.left_seed_label_top.caption = "Cost: " .. createMonetaryString(price)
        end
    end

    for _, line in pairs(lines) do
        line:hide()
    end

    local ship = Entity(Player().craftIndex)
    if not ship then return end

    for i, ingredient in pairs(ingredients) do
        local line = TurretFactory.UI.lines[i]
        line:show()

        if ingredient.default == nil then ingredient.default = ingredient.amount end

        local good = goods[ingredient.name]:good()

        local needed = ingredient.amount * (tonumber(TurretFactory.UI.bulkTextBox.text) or 1)
        local have = ship:getCargoAmount(good) or 0

        line.icon.picture = good.icon
        line.material.caption = good:displayName(needed)
        line.required.caption = needed
        line.you.caption = have

        line.plus.visible = (ingredient.amount < ingredient.maximum)
        line.minus.visible = (ingredient.amount > ingredient.minimum)

        if have < needed then
            line.you.color = ColorRGB(1, 0, 0)
        else
            line.you.color = ColorRGB(1, 1, 1)
        end
    end

    if not tonumber(TurretFactory.UI.bulkTextBox.text) then TurretFactory.UI.bulkTextBox.text = "1" end
    if tonumber(TurretFactory.UI.bulkTextBox.text) > 1 then
        TurretFactory.UI.priceLabel.caption = "Bulk Cost: $${bulk_money} ($${money})"%_t % {bulk_money = createMonetaryString(price*round(tonumber(TurretFactory.UI.bulkTextBox.text))), money = createMonetaryString(price)}
    else
        TurretFactory.UI.priceLabel.caption = "Manufacturing Cost: $${money}"%_t % {money = createMonetaryString(price)}
    end

    for _, line in pairs(TurretFactory.UI.stat_lines) do
        line:hide()
    end

    TurretFactory.getUISeed()
    TurretFactory.current_turret = TurretFactory.makeTurret(TurretFactory.getUIWeapon(), TurretFactory.getUIRarity(), TurretFactory.getMaterial(), TurretFactory.getUIIngredients())
    TurretFactory.UI.turret_tooltip = makeTurretTooltip(TurretFactory.current_turret)
    TurretFactory.UI.turret_tooltip_lines = {TurretFactory.UI.turret_tooltip:getLines()}
    local skipped = 0
    for i, tooltip_line in pairs(TurretFactory.UI.turret_tooltip_lines) do
        local exclude = false
        for _, line in pairs(Config.ignore_tooltips) do
            if string.find(tooltip_line.ltext, line) then
                exclude = true
            end
        end
        if TurretFactory.tonumber(tooltip_line.rtext) == nil or exclude then
            skipped = skipped + 1
        else
            local line = TurretFactory.UI.stat_lines[i-skipped]

            line.stat.caption = tooltip_line.ltext

            line:show()
        end
    end
    local line = TurretFactory.UI.stat_lines[#TurretFactory.UI.turret_tooltip_lines-skipped+1]
    line.stat.caption = "Coaxial"
    line:show()
    --local line = TurretFactory.UI.stat_lines[#TurretFactory.UI.turret_tooltip_lines-skipped+2]
    --line.stat.caption = "Automatic"
    --line:show()

    if (TurretFactory.weighted_unsorted_Turret_List == nil or TurretFactory.weighted_unsorted_Turret_List == {}) and TurretFactory.max_seed then TurretFactory.quick_sort_Turrets() end
end

--UI Functions
function TurretFactory.renderUI() -- Overriding vanilla (not needed just cheaper)
    if type(TurretFactory.UI.turret_tooltip) == "userdata" then
        local renderer = TooltipRenderer(TurretFactory.UI.turret_tooltip)
        renderer:draw(vec2(window.upper.x, window.lower.y) + vec2(20, 10))
    end
end

function TurretFactory.getUISeed()
    TurretFactory.seed = tonumber(TurretFactory.UI.seed_text_box.text) or 0
    return TurretFactory.seed
end

function TurretFactory.bulkChanged()
    if not tonumber(TurretFactory.UI.bulkTextBox.text) then return end
    if tonumber(TurretFactory.UI.bulkTextBox.text) == 0 then TurretFactory.UI.bulkTextBox.text = "1" end
    TurretFactory.refreshUI()
end

function TurretFactory.onSeedTextBox(_, click)
    local stat_lines_memory = {}
    for _, stat_line in pairs(TurretFactory.UI.stat_lines) do
        local local_line = {}
        local_line.text = stat_line.text_box.text
        local_line.checked = stat_line.checkbox.checked
        stat_lines_memory[stat_line.stat.caption] = local_line
    end
    TurretFactory.onClear()

    TurretFactory.UI.seed_index = TurretFactory.UI.seed_index or 1
    TurretFactory.UI.seed_index = math.max(math.min(TurretFactory.UI.seed_index, #TurretFactory.weighted_unsorted_Turret_List),1)
    if (not TurretFactory.UI.seed_text_box.isTypingActive) or click then TurretFactory.UI.seed_text_box.text = TurretFactory.weighted_unsorted_Turret_List[TurretFactory.UI.seed_index].seed end

    TurretFactory.UI.middle_seed_label_top.caption = "Sum: " .. TurretFactory.weighted_unsorted_Turret_List[TurretFactory.UI.seed_index].sum

    if Config.seedsBuyable then
        if not TurretFactory.max_seed then TurretFactory.syncMaxSeed() end
        if tonumber(TurretFactory.UI.seed_text_box.text) then TurretFactory.UI.seed_text_box.text = math.max(math.min(tonumber(TurretFactory.UI.seed_text_box.text), TurretFactory.max_seed or 0),0) end
    end

    TurretFactory.refreshUI()
    for _, stat_line in pairs(TurretFactory.UI.stat_lines) do
        if stat_lines_memory[stat_line.stat.caption] then
            stat_line.text_box.text = stat_lines_memory[stat_line.stat.caption].text
            stat_line.checkbox.checked = stat_lines_memory[stat_line.stat.caption].checked
        end
    end
end

function TurretFactory.onSeedNext()
    TurretFactory.UI.seed_index = TurretFactory.UI.seed_index - 1
    TurretFactory.onSeedTextBox(nil, true)
end

function TurretFactory.onSeedPrev()
    TurretFactory.UI.seed_index = TurretFactory.UI.seed_index + 1
    TurretFactory.onSeedTextBox(nil, true)
end

function TurretFactory.onSearch()
    TurretFactory.quick_sort_Turrets()
    TurretFactory.onSeedTextBox(nil, true)
end

function TurretFactory.onClear()
    for _, stat_line in pairs(TurretFactory.UI.stat_lines) do
        stat_line.checkbox.checked = false
        stat_line.text_box.text = 0
    end
end

function TurretFactory.clearTurretList()
    TurretFactory.unsorted_Turret_List = {}
end

local onTurretTypeSelect_old = TurretFactory.onTurretTypeSelect
function TurretFactory.onTurretTypeSelect() -- vanilla
    TurretFactory.clearTurretList()
    TurretFactory.onClear()
    onTurretTypeSelect_old()
end

local onRaritySelect_old = TurretFactory.onRaritySelect
function TurretFactory.onRaritySelect() -- vanilla
    TurretFactory.clearTurretList()
    TurretFactory.onClear()
    onRaritySelect_old()
end

local onNext_old = TurretFactory.onNext
function TurretFactory.onNext() -- vanilla
    TurretFactory.clearTurretList()
    onNext_old()
end

local onPrev_old = TurretFactory.onPrev
function TurretFactory.onPrev() -- vanilla
    TurretFactory.clearTurretList()
    onPrev_old()
end

function TurretFactory.onMaxCheckBox()
    for _, ingredient in pairs(TurretFactory.getUIIngredients()) do
        if not (ingredient.name == "Targeting System") then
            if TurretFactory.UI.max_checkbox.checked then
                ingredient.amount = ingredient.maximum
            else
                ingredient.amount = ingredient.default
            end
        end
    end
    TurretFactory.clearTurretList()
    TurretFactory.refreshUI()
end

function TurretFactory.onHelp()
    if TurretFactory.UI.help_checkbox.checked then
        TurretFactory.UI.help_checkbox.tooltip  = "Enables help tooltips for everything. \n(that wants to have a tooltip)"
        TurretFactory.UI.bulkTextBox.tooltip    = "For crafting multiple turrets at once."
        TurretFactory.UI.max_checkbox.tooltip   = "Fills the ingredients \nwhen crafting/searching turrets."
        TurretFactory.UI.seed_text_box.tooltip  = "The current seed selected."
        TurretFactory.UI.clear_button.tooltip   = "Resets all the stats back to default in the above list."
        TurretFactory.UI.search_button.tooltip  = "Searches for turrets with the given traits."
        TurretFactory.UI.middle_seed_label_top.tooltip = "Current overall value of turret, higher is better. \nOnly updates on prev/next."
        for _, line in pairs(TurretFactory.UI.stat_lines) do
            line.checkbox.tooltip   = "Is this stat enabled in the search?"
            line.stat.tooltip       = "The name of the stat."
            line.text_box.tooltip   = "Used to filter out turrets that don't meet the required value. \nCheck help box for more info."
        end
        if Config.seedsBuyable then
            TurretFactory.UI.upgrade_button.tooltip = "Used to buy more seeds."
        else
            TurretFactory.UI.left_seed_text_box.tooltip = "Enter a starting seed to search for turrets between the range."
        end
    else
        TurretFactory.UI.help_checkbox.tooltip  = nil
        TurretFactory.UI.bulkTextBox.tooltip    = nil
        TurretFactory.UI.max_checkbox.tooltip   = nil
        TurretFactory.UI.seed_text_box.tooltip  = nil
        TurretFactory.UI.clear_button.tooltip   = nil
        TurretFactory.UI.search_button.tooltip  = nil
        TurretFactory.UI.middle_seed_label_top.tooltip = nil
        for _, line in pairs(TurretFactory.UI.stat_lines) do
            line.checkbox.tooltip   = nil
            line.stat.tooltip       = nil
            line.text_box.tooltip   = nil
        end
        if Config.seedsBuyable then
            TurretFactory.UI.upgrade_button.tooltip = nil
        else
            TurretFactory.UI.left_seed_text_box.tooltip = nil
        end
    end
end

function TurretFactory.onBuildButtonPressed()  -- Overriding vanilla
    invokeServerFunction("syncSeed", TurretFactory.getUISeed())
    invokeServerFunction("buildTurret", TurretFactory.getUIWeapon(), TurretFactory.getUIRarity(), TurretFactory.getMaterial(), TurretFactory.getUIIngredients())
end

function TurretFactory.onUpgrade()
    if onClient() then
        invokeServerFunction("onUpgrade")
        return
    end

    TurretFactory.max_seed = TurretFactory.max_seed or 0

    local buyer, ship, player = getInteractingFaction(callingPlayer, AlliancePrivilege.FoundStations)
    if not buyer then return end

    local price = (Config.upgradeBasePrice + (Config.upgradeBasePrice * 0.1 * TurretFactory.max_seed)) * Config.upgradeAmount

    local canPay, msg, args = buyer:canPay(price)
    if not canPay then
        sendError(player, msg, unpack(args))
        return
    end

    if TurretFactory.max_seed + Config.upgradeAmount > Config.max_buyable then return end

    TurretFactory.max_seed = TurretFactory.max_seed + Config.upgradeAmount
    buyer:pay(price)

    TurretFactory.syncMaxSeed()
end
callable(TurretFactory,"onUpgrade")
--UI Functions End

--Clientside Search Functions
function TurretFactory.find_Max_Values()
    for _, turret_obj in pairs(TurretFactory.unsorted_Turret_List) do
        for _, stat_line in pairs(TurretFactory.UI.stat_lines) do
            if TurretFactory.max_stats[stat_line.stat.caption] == nil then TurretFactory.max_stats[stat_line.stat.caption] = 0 end
            if turret_obj[stat_line.stat.caption] then
                if TurretFactory.max_stats[stat_line.stat.caption] < turret_obj[stat_line.stat.caption] then
                    TurretFactory.max_stats[stat_line.stat.caption] = turret_obj[stat_line.stat.caption]
                end
            end
        end
    end
end

function TurretFactory.split(str,sep)
    local sep, fields = sep or ":", {}
    local pattern = string.format("([^%s]+)", sep)
    str:gsub(pattern, function(c) fields[#fields+1] = c end)
    return fields
end

function TurretFactory.tonumber(str)
    if string.find(str,"x") then
        local array = TurretFactory.split(str,"x")
        if not tonumber(array[1]) then return nil end
        return tonumber(array[1])*tonumber(array[2])
    end
    return tonumber(string.match(str,"(%d*%.?%d+)"))
end

function TurretFactory.generate_Turret_Stat_Obj(seed)
    local turret_obj = {}
    TurretFactory.seed = seed
    local turret = TurretFactory.makeTurret(TurretFactory.getUIWeapon(), TurretFactory.getUIRarity(), TurretFactory.getMaterial(), TurretFactory.getUIIngredients())
    turret_obj.seed = seed
    turret_obj.Coaxial = turret.coaxial and 1 or 0
    --turret_obj.Automatic = turret.automatic and 1 or 0
    --TODO potentially add turningSpeed and damageMultiplier from turret
    local tooltip = makeTurretTooltip(turret)
    for _, tooltip_line in pairs({tooltip:getLines()}) do
        turret_obj[tooltip_line.ltext] = TurretFactory.tonumber(tooltip_line.rtext)
    end
    return turret_obj
end

function TurretFactory.generate_Turret_List()

    TurretFactory.unsorted_Turret_List = {}
    TurretFactory.weighted_unsorted_Turret_List = {}
    TurretFactory.max_stats = {}
    local oldseed = TurretFactory.seed

    if Config.seedsBuyable then
        if TurretFactory.max_seed == nil then
            TurretFactory.syncMaxSeed()
            deferredCallback(0.2, "generate_Turret_list")
            return
        end

        for i = 0, TurretFactory.max_seed do
            table.insert(TurretFactory.unsorted_Turret_List, TurretFactory.generate_Turret_Stat_Obj(i))
        end
    else
        local searchrange = tonumber(TurretFactory.UI.left_seed_text_box.text) or 0
        for i = searchrange, searchrange + Config.sample_size do
            table.insert(TurretFactory.unsorted_Turret_List, TurretFactory.generate_Turret_Stat_Obj(i))
        end
    end

    TurretFactory.find_Max_Values()

    for _, turret_obj in pairs(TurretFactory.unsorted_Turret_List) do -- weighting stats off max
        local weighted_obj = {}
        for stat, value in pairs(TurretFactory.max_stats) do
            if turret_obj[stat] then
                weighted_obj[stat] = turret_obj[stat]/value
            end
        end
        weighted_obj.seed = turret_obj.seed
        table.insert(TurretFactory.weighted_unsorted_Turret_List,weighted_obj)
    end

    TurretFactory.seed = oldseed

end

function TurretFactory.generate_Turret_Weighted_List()
    for _, turret_obj in pairs(TurretFactory.weighted_unsorted_Turret_List) do
        turret_obj.sum = 0
        for _, stat_line in pairs(TurretFactory.UI.stat_lines) do
            if turret_obj[stat_line.stat.caption] then
                if stat_line.checkbox.checked then
                    if string.find(stat_line.text_box.text,"!") then
                        turret_obj.sum = turret_obj.sum + -1*turret_obj[stat_line.stat.caption]
                    else
                        turret_obj.sum = turret_obj.sum + turret_obj[stat_line.stat.caption]
                    end
                end
                if stat_line.text_box.text == "" then stat_line.text_box.text = 0 end
                if turret_obj[stat_line.stat.caption]*TurretFactory.max_stats[stat_line.stat.caption] < TurretFactory.tonumber(stat_line.text_box.text) and not string.find(stat_line.text_box.text, "-") then
                    turret_obj.sum = turret_obj.sum-10
                elseif turret_obj[stat_line.stat.caption]*TurretFactory.max_stats[stat_line.stat.caption] > TurretFactory.tonumber(stat_line.text_box.text) and string.find(stat_line.text_box.text, "-") then
                    turret_obj.sum = turret_obj.sum-10
                end
            end
        end
    end
end

function TurretFactory.quickSort(array, p, r)
    p = p or 1
    r = r or #array
    if p < r then
        q = TurretFactory.partition(array, p, r)
        TurretFactory.quickSort(array, p, q - 1)
        TurretFactory.quickSort(array, q + 1, r)
    end
end

function TurretFactory.partition(array, p, r)
    local x = array[r].sum
    local i = p - 1
    for j = p, r - 1 do
        if array[j].sum <= x then
            i = i + 1
            local temp = array[i]
            array[i] = array[j]
            array[j] = temp
        end
    end
    local temp = array[i + 1]
    array[i + 1] = array[r]
    array[r] = temp
    return i + 1
end

function TurretFactory.quick_sort_Turrets()
    if #TurretFactory.unsorted_Turret_List == 0 then TurretFactory.generate_Turret_List() end
    TurretFactory.generate_Turret_Weighted_List()
    TurretFactory.quickSort(TurretFactory.weighted_unsorted_Turret_List,1, #TurretFactory.weighted_unsorted_Turret_List)
    TurretFactory.UI.seed_index = #TurretFactory.weighted_unsorted_Turret_List
end
--Clientside Search Functions end

function TurretFactory.syncSeed(seed)
    if Config.seedsBuyable then
        seed = math.max(math.min(seed, TurretFactory.max_seed or 0),0)
    end
    TurretFactory.seed = seed
end
callable(TurretFactory, "syncSeed")

function TurretFactory.syncMaxSeed(max_seed)

    if onClient() then

        TurretFactory.clearTurretList()

        if not max_seed then
            return invokeServerFunction("syncMaxSeed")
        end

        TurretFactory.UI.left_seed_label_bottom.caption = "Currently Unlocked: " .. max_seed
        TurretFactory.max_seed = max_seed
        TurretFactory.refreshUI()
        return

    end

    invokeClientFunction(Player(callingPlayer),"syncMaxSeed",TurretFactory.max_seed or 0)

end
callable(TurretFactory, "syncMaxSeed")

function TurretFactory.makeTurretBase(weaponType, rarity, material) -- Overriding vanilla
    local station = Entity()
    local x, y = Sector():getCoordinates()

    if onClient() and (TurretFactory.seed == nil) then TurretFactory.getUISeed() end

    local seed = station.index.number + 123 + x + y * 300 + TurretFactory.seed

    TurretGenerator.initialize(Seed(seed))
    local turret = TurretGenerator.generate(x, y, 0, rarity, weaponType, material)

    -- automatic turrets must get automatic property removed and damage rebuffed
    -- we don't want the base turrets to have independent targeting since that can mess up the rest of the stats calculation, especially for damage
    if turret.automatic then
        turret.automatic = false

        local weapons = {turret:getWeapons()}
        turret:clearWeapons()

        for _, weapon in pairs(weapons) do
            weapon.damage = weapon.damage * 2.0
            if weapon.hullRepair > 0.0 then
                weapon.hullRepair = weapon.hullRepair * 2.0
            end
            if weapon.shieldRepair > 0.0 then
                weapon.shieldRepair = weapon.shieldRepair * 2.0
            end

            turret:addWeapon(weapon)
        end
    end

    return turret
end