# ----------
# Channel Management
#
# Detailed explanations: https://gitea.0bin.xyz/pegasus/tclscripts/src/branch/main/Chanban#readme
# ----------
namespace eval cmgmt {
    # ----------
    # Configuration
    # ----------
    # Language to be use on this script
    # Available languages: en (English)
    variable locale "en"

    # Directory where the language files are located
    variable lang_dir "scripts/cmgmt_langs"

    # Trigger to be used
    variable trigger "@"

    # Temporary ban duration, in minutes
    variable tBanDuration "30"

    # Command to upload the file
    # The ban list file is piped into the command via stdin (with `cat $filename |`)
    # so your command must read from stdin
    variable upCommand "curl -s -F file=@- https://x0.at/"

    # Set the banmask type to use in banning the user
    #	Available types are:
    #	0 *!user@host
    #	1 *!*user@host
    #	2 *!*@host
    #	3 *!*user@*.host
    #	4 *!*@*.host
    #	5 nick!user@host
    #	6 nick!*user@host
    #	7 nick!*@host
    #	8 nick!*user@*.host
    #	9 nick!*@*.host
    variable banMask "2"

    # Masks to protect from bans, always on the format *!ident@hostname
    variable protectMasks {
        *!*@services.ptirc.org
    }

    # Nicks to ignore for auto adding bans
    variable noAddNicks {
        ChanServ
        NickServ
        ChanBot
    }

    # Masks to ignore for auto adding bans
    variable noAddMasks {
        *!*@services.ptirc.org
    }

    # ----------
    # Binds
    # ----------
    ### Public
    bind pub * ${::cmgmt::trigger}ban ::cmgmt::ban_pub
    bind pub * ${::cmgmt::trigger}tban ::cmgmt::tban_pub
    bind pub * ${::cmgmt::trigger}kick ::cmgmt::kick_pub
    bind pub * ${::cmgmt::trigger}voice ::cmgmt::voice_pub
    bind pub * ${::cmgmt::trigger}devoice ::cmgmt::devoice_pub
    bind pub * ${::cmgmt::trigger}unban ::cmgmt::unban_pub
    bind pub * ${::cmgmt::trigger}banlist ::cmgmt::banlist_pub
    bind pub * ${::cmgmt::trigger}autoadd ::cmgmt::autoban_pub
    bind pub * ${::cmgmt::trigger}opcmds ::cmgmt::opcmds_pub

    ### Private
    bind msg * ban ::cmgmt::ban_msg
    bind msg * tban ::cmgmt::tban_msg
    bind msg * kick ::cmgmt::kick_msg
    bind msg * unban ::cmgmt::unban_msg
    bind msg * voice ::cmgmt::voice_msg
    bind msg * devoice ::cmgmt::devoice_msg
    bind msg * banlist ::cmgmt::banlist_msg
    bind msg * autoadd ::cmgmt::autoban_msg
    bind msg * opcmds ::cmgmt::opcmds_msg

    # ----------
    # Auto add bans
    # ----------
    # Add bans
    bind mode * "*+b*" ::cmgmt::abans
    bind mode * "*-b*" ::cmgmt::rbans

    # Channel flag to auto add bans to the bot ban list
    setudef flag addBans

    # ----------
    # End of configuration
    # ----------

    # ----------
    # DON'T TOUCH ANYTHING BELOW UNLESS YOU KNOW WHAT YOU ARE DOING
    #
    # If you touch the code below and then complain the script "suddenly stopped working" I'll touch you at night.
    # ----------
    if { [catch { package require msgcat }] } {
        putloglev o * "\[Channel Management\] This script needs msgcat package to work. The script cannot be loaded."
        return
    }
    ::msgcat::mclocale $::cmgmt::locale
    ::msgcat::mcload [file join $cmgmt::lang_dir]

    # ----------
    # Script name and author
     variable scriptName "Channel Management v1.0 \(03/03/2026-09:30\)"
     variable scriptAuthor "PeGaSuS"

    # ----------
    # Public procs
    # ----------
    ### Pub Ban
    proc ban_pub {nick uhost hand chan text} {
        if {![matchattr $hand o|o $chan]} {
            putserv "NOTICE $nick :[format [::msgcat::mc error.no.access] $nick]"
            return 0
        }

        set target [lindex [split $text] 0]

        if {$target eq ""} {
            putserv "PRIVMSG $chan :[format [::msgcat::mc error.syntax] $::cmgmt::trigger]ban <nick>"
            return 0
        }

        if {![onchan $target $chan]} {
            putserv "PRIVMSG $chan :[format [::msgcat::mc not.on.chan] $target $chan]"
            return 0
        }

        if {$target eq $::botnick} {
            putkick $chan $nick [::msgcat::mc revenge.kick]
            return 0
        }

        if {[isop $target $chan] || [matchattr [nick2hand $target] o|o $chan]} {
            putserv "NOTICE $nick :[format [::msgcat::mc protected.user] $target]"
            return 0
        }

        set bhost [string trim [getchanhost $target $chan] ~]

        foreach pmask $::cmgmt::protectMasks {
            if {[matchstr $pmask "${target}!$bhost"] || [matchstr "${target}!$bhost" $pmask]} {
                putserv "NOTICE $nick :[format [::msgcat::mc protected.user] $target]"
                return 0
            }
        }

        if {[matchstr "uid*" $bhost] || [matchstr "sid*" $bhost]} {
            set banmask *!*$bhost
        } else {
            set banmask [maskhost ${target}![getchanhost $target $chan] $::cmgmt::banMask]
        }

        newchanban $chan $banmask $nick [::msgcat::mc ban.reason] 0
        pushmode $chan +b $banmask
        putkick $chan $target [::msgcat::mc ban.reason]
        putserv "PRIVMSG $chan :[format [::msgcat::mc ban.added] $banmask $chan]"
        return 0
    }

    ### Pub Tban
    proc tban_pub {nick uhost hand chan text} {
        if {![matchattr $hand o|o $chan]} {
            putserv "NOTICE $nick :[format [::msgcat::mc error.no.access] $nick]"
            return 0
        }

        set target [lindex [split $text] 0]

        if {$target eq ""} {
            putserv "PRIVMSG $chan :[format [::msgcat::mc error.syntax] $::cmgmt::trigger]tban <nick>"
            return 0
        }

        if {![onchan $target $chan]} {
            putserv "PRIVMSG $chan :[format [::msgcat::mc not.on.chan] $target $chan]"
            return 0
        }

        if {$target eq $::botnick} {
            putkick $chan $nick [::msgcat::mc revenge.kick]
            return 0
        }

        if {[isop $target $chan] || [matchattr [nick2hand $target] o|o $chan]} {
            putserv "NOTICE $nick :[format [::msgcat::mc protected.user] $target]"
            return 0
        }

        set bhost [string trim [getchanhost $target $chan] ~]

        foreach pmask $::cmgmt::protectMasks {
            if {[matchstr $pmask "${target}!$bhost"] || [matchstr "${target}!$bhost" $pmask]} {
                putserv "NOTICE $nick :[format [::msgcat::mc protected.user] $target]"
                return 0
            }
        }

        if {[matchstr "uid*" $bhost] || [matchstr "sid*" $bhost]} {
            set banmask *!*$bhost
        } else {
            set banmask [maskhost ${target}![getchanhost $target $chan] $::cmgmt::banMask]
        }

        newchanban $chan $banmask $nick [::msgcat::mc temp.ban.reason] $::cmgmt::tBanDuration
        pushmode $chan +b $banmask
        putkick $chan $target [::msgcat::mc temp.ban.reason]
        putserv "PRIVMSG $chan :[format [::msgcat::mc tmp.ban.added] $banmask $chan]"
        return 0
    }

    ### Pub Kick
    proc kick_pub {nick uhost hand chan text} {
        if {![matchattr $hand o|o $chan]} {
            putserv "NOTICE $nick :[format [::msgcat::mc error.no.access] $nick]"
            return 0
        }

        set target [lindex [split $text] 0]

        if {$target eq ""} {
            putserv "PRIVMSG $chan :[format [::msgcat::mc error.syntax] $::cmgmt::trigger]kick <nick>"
            return 0
        }

        if {![onchan $target $chan]} {
            putserv "PRIVMSG $chan :[format [::msgcat::mc not.on.chan] $target $chan]"
            return 0
        }

        if {$target eq $::botnick} {
            putkick $chan $nick [::msgcat::mc revenge.kick]
            return 0
        }

        if {[isop $target $chan] || [matchattr [nick2hand $target] o|o $chan]} {
            putserv "NOTICE $nick :[format [::msgcat::mc protected.user] $target]"
            return 0
        }

        putkick $chan $target [::msgcat::mc kick.reason]
        return 0
    }

    ### Pub Voice
    proc voice_pub {nick uhost hand chan text} {
        if {![matchattr $hand o|o $chan]} {
            putserv "NOTICE $nick :[format [::msgcat::mc error.no.access] $nick]"
            return 0
        }

        set target [lindex [split $text] 0]

        if {$target eq ""} {
            putserv "PRIVMSG $chan :[format [::msgcat::mc error.syntax] $::cmgmt::trigger]voice <nick>"
            return 0
        }

        if {![onchan $target $chan]} {
            putserv "PRIVMSG $chan :[format [::msgcat::mc not.on.chan] $target $chan]"
            return 0
        }

        if {[isop $target $chan] || [matchattr [nick2hand $target] o|o $chan]} {
            putserv "NOTICE $nick :[format [::msgcat::mc protected.user] $target]"
            return 0
        }

        pushmode $chan +v $target
        return 0
    }

    ### Pub Devoice
    proc devoice_pub {nick uhost hand chan text} {
        if {![matchattr $hand o|o $chan]} {
            putserv "NOTICE $nick :[format [::msgcat::mc error.no.access] $nick]"
            return 0
        }

        set target [lindex [split $text] 0]

        if {$target eq ""} {
            putserv "PRIVMSG $chan :[format [::msgcat::mc error.syntax] $::cmgmt::trigger]devoice <nick>"
            return 0
        }

        if {![onchan $target $chan]} {
            putserv "PRIVMSG $chan :[format [::msgcat::mc not.on.chan] $target $chan]"
            return 0
        }

        if {[isop $target $chan] || [matchattr [nick2hand $target] o|o $chan]} {
            putserv "NOTICE $nick :[format [::msgcat::mc protected.user] $target]"
            return 0
        }

        pushmode $chan -v $target
        return 0
    }

    ### Pub Unban
    proc unban_pub {nick uhost hand chan text} {
        if {![matchattr $hand o|o $chan]} {
            putserv "NOTICE $nick :[format [::msgcat::mc error.no.access] $nick]"
            return 0
        }

        set banmask [lindex [split $text] 0]

        if {$banmask eq ""} {
            putserv "PRIVMSG $chan :[format [::msgcat::mc error.syntax] $::cmgmt::trigger]unban <mask>"
            return 0
        }

        if {![isban $banmask $chan]} {
            putserv "PRIVMSG $chan :[format [::msgcat::mc not.ban.mask] $banmask $chan]"
            return 0
        }

        killchanban $chan $banmask
        pushmode $chan -b $banmask
        putserv "PRIVMSG $chan :[format [::msgcat::mc ban.removed] $banmask $chan]"
        return 0
    }

    ### Pub Banlist
    proc banlist_pub {nick uhost hand chan text} {
        if {![matchattr $hand o|o $chan]} {
            putserv "NOTICE $nick :[format [::msgcat::mc error.no.access] $nick]"
            return 0
        }

        set cbans [banlist $chan]
        set cbans [lsearch -all -inline -not -index 1 $cbans "EXTBAN"]
        if {[llength $cbans] == 0} {
            putserv "PRIVMSG $chan :[format [::msgcat::mc banlist.empty] $chan]"
            return 0
        }

        set filename [string trim "$chan" #]_banlist.txt
        set bancount [llength $cbans]

        set blist [open $filename "w"]
        set i 1
        puts $blist "[format [::msgcat::mc banlist.open] $chan $bancount]"
        puts $blist ""

        foreach botban $cbans {
            set banmask [lindex $botban 0]
            set reason [lindex $botban 1]
            if {[isbansticky $banmask $chan]} {
                set freason "$reason \(sticky\)"
            } else {
                set freason "$reason"
            }
            set tstamp [lindex $botban 3]
            set date [clock format $tstamp -format "%d/%m/%Y - %H:%M:%S"]
            set creator [lindex $botban end]
            puts $blist "\[${i}\] [format [::msgcat::mc banlist.format] $banmask $freason $creator $date]"
            puts $blist ""
            incr i
        }

        puts $blist "[format [::msgcat::mc banlist.end] $chan]"
        puts $blist ""
        puts $blist "[format [::msgcat::mc banlist.explain] $::cmgmt::trigger]unban <banmask>"
        close $blist

        if {[catch {
            set result [exec cat $filename | {*}$::cmgmt::upCommand]
        } err]} {
            putserv "PRIVMSG $chan :[format [::msgcat::mc banlist.upload.fail] $err]"
            file delete $filename
            return 0
        }

        putserv "PRIVMSG $chan :[format [::msgcat::mc banlist.url] $chan $result]"
        file delete $filename
        return 0
    }

    ### Pub Autoadd
    proc autoban_pub {nick uhost hand chan text} {
        if {![matchattr $hand o|o $chan]} {
            putserv "NOTICE $nick :[format [::msgcat::mc error.no.access] $nick]"
            return 0
        }

        set option [lindex [split $text] 0]

        switch $option {
            on {
                if {[channel get $chan addBans]} {
                    putserv "PRIVMSG $chan :[format [::msgcat::mc autoadd.enabled] $chan]"
                    return 0
                } else {
                    channel set $chan +addBans
                    putserv "PRIVMSG $chan :[format [::msgcat::mc autoadd.enable] $chan]"
                    return 0
                }
            }

            off {
                if {![channel get $chan addBans]} {
                    putserv "PRIVMSG $chan :[format [::msgcat::mc autoadd.disabled] $chan]"
                    return 0
                } else {
                    channel set $chan -addBans
                    putserv "PRIVMSG $chan :[format [::msgcat::mc autoadd.disable] $chan]"
                    return 0
                }
            }

            status {
                if {[channel get $chan addBans]} {
                    set turned "enabled"
                } else {
                    set turned "disabled"
                }
                putserv "PRIVMSG $chan :[format [::msgcat::mc autoadd.status] $turned $chan]"
                return 0
            }

            default {
                putserv "PRIVMSG $chan :[format [::msgcat::mc error.syntax] $::cmgmt::trigger]autoadd <on/off/status>"
                return 0
            }
        }
        return 0
    }

    ### Pub OPcmds
    proc opcmds_pub {nick uhost hand chan text} {
        if {![matchattr $hand o|o $chan]} {
            putserv "NOTICE $nick :[format [::msgcat::mc error.no.access] $nick]"
            return 0
        }

        putserv "PRIVMSG $chan :[format [::msgcat::mc cmgmt.cmds] $::cmgmt::trigger]"
        return 0
    }

    # ----------
    # Private procs
    # ----------
    ### PM Ban
    proc ban_msg {nick uhost hand text} {
        set chan [lindex [split $text] 0]

        if {![matchstr "#*" $chan]} {
            putserv "PRIVMSG $nick :[::msgcat::mc pm.error.syntax] ban <#chan> <nick>"
            return 0
        }

        if {![validchan $chan]} {
            putserv "PRIVMSG $nick :[format [::msgcat::mc bot.not.onchan] $chan]"
            return 0
        }

        if {![matchattr $hand o|o $chan]} {
            putserv "PRIVMSG $nick :[format [::msgcat::mc error.no.access] $nick]"
            return 0
        }

        set target [lindex [split $text] 1]

        if {$target eq ""} {
            putserv "PRIVMSG $nick :[::msgcat::mc pm.error.syntax] ban <#chan> <nick>"
            return 0
        }

        if {![onchan $target $chan]} {
            putserv "PRIVMSG $nick :[format [::msgcat::mc not.on.chan] $target $chan]"
            return 0
        }

        if {$target eq $::botnick} {
            putkick $chan $nick [::msgcat::mc revenge.kick]
            return 0
        }

        if {[isop $target $chan] || [matchattr [nick2hand $target] o|o $chan]} {
            putserv "PRIVMSG $nick :[format [::msgcat::mc protected.user] $target]"
            return 0
        }

        set bhost [string trim [getchanhost $target $chan] ~]

        foreach pmask $::cmgmt::protectMasks {
            if {[matchstr $pmask "${target}!$bhost"] || [matchstr "${target}!$bhost" $pmask]} {
                putserv "PRIVMSG $nick :[format [::msgcat::mc protected.user] $target]"
                return 0
            }
        }

        if {[matchstr "uid*" $bhost] || [matchstr "sid*" $bhost]} {
            set banmask *!*$bhost
        } else {
            set banmask [maskhost ${target}![getchanhost $target $chan] $::cmgmt::banMask]
        }

        newchanban $chan $banmask $nick [::msgcat::mc ban.reason] 0
        pushmode $chan +b $banmask
        putkick $chan $target [::msgcat::mc ban.reason]
        putserv "PRIVMSG $nick :[format [::msgcat::mc ban.added] $banmask $chan]"
        return 0
    }

    ### PM Tban
    proc tban_msg {nick uhost hand text} {
        set chan [lindex [split $text] 0]

        if {![matchstr "#*" $chan]} {
            putserv "PRIVMSG $nick :[::msgcat::mc pm.error.syntax] tban <#chan> <nick>"
            return 0
        }

        if {![validchan $chan]} {
            putserv "PRIVMSG $nick :[format [::msgcat::mc bot.not.onchan] $chan]"
            return 0
        }

        if {![matchattr $hand o|o $chan]} {
            putserv "PRIVMSG $nick :[format [::msgcat::mc error.no.access] $nick]"
            return 0
        }

        set target [lindex [split $text] 1]

        if {$target eq ""} {
            putserv "PRIVMSG $nick :[::msgcat::mc pm.error.syntax] tban <#chan> <nick>"
            return 0
        }

        if {![onchan $target $chan]} {
            putserv "PRIVMSG $nick :[format [::msgcat::mc not.on.chan] $target $chan]"
            return 0
        }

        if {$target eq $::botnick} {
            putkick $chan $nick [::msgcat::mc revenge.kick]
            return 0
        }

        if {[isop $target $chan] || [matchattr [nick2hand $target] o|o $chan]} {
            putserv "PRIVMSG $nick :[format [::msgcat::mc protected.user] $target]"
            return 0
        }

        set bhost [string trim [getchanhost $target $chan] ~]

        foreach pmask $::cmgmt::protectMasks {
            if {[matchstr $pmask "${target}!$bhost"] || [matchstr "${target}!$bhost" $pmask]} {
                putserv "PRIVMSG $nick :[format [::msgcat::mc protected.user] $target]"
                return 0
            }
        }

        if {[matchstr "uid*" $bhost] || [matchstr "sid*" $bhost]} {
            set banmask *!*$bhost
        } else {
            set banmask [maskhost ${target}![getchanhost $target $chan] $::cmgmt::banMask]
        }

        newchanban $chan $banmask $nick [::msgcat::mc temp.ban.reason] $::cmgmt::tBanDuration
        pushmode $chan +b $banmask
        putkick $chan $target [::msgcat::mc temp.ban.reason]
        putserv "PRIVMSG $nick :[format [::msgcat::mc tmp.ban.added] $banmask $chan]"
        return 0
    }

    ### PM Kick
    proc kick_msg {nick uhost hand text} {
        set chan [lindex [split $text] 0]

        if {![matchstr "#*" $chan]} {
            putserv "PRIVMSG $nick :[::msgcat::mc pm.error.syntax] kick <#chan> <nick>"
            return 0
        }

        if {![validchan $chan]} {
            putserv "PRIVMSG $nick :[format [::msgcat::mc bot.not.onchan] $chan]"
            return 0
        }

        if {![matchattr $hand o|o $chan]} {
            putserv "PRIVMSG $nick :[format [::msgcat::mc error.no.access] $nick]"
            return 0
        }

        set target [lindex [split $text] 1]

        if {$target eq ""} {
            putserv "PRIVMSG $nick :[::msgcat::mc pm.error.syntax] kick <#chan> <nick>"
            return 0
        }

        if {![onchan $target $chan]} {
            putserv "PRIVMSG $nick :[format [::msgcat::mc not.on.chan] $target $chan]"
            return 0
        }

        if {$target eq $::botnick} {
            putkick $chan $nick [::msgcat::mc revenge.kick]
            return 0
        }

        if {[isop $target $chan] || [matchattr [nick2hand $target] o|o $chan]} {
            putserv "PRIVMSG $nick :[format [::msgcat::mc protected.user] $target]"
            return 0
        }
        putkick $chan $target [::msgcat::mc kick.reason]
        return 0
    }

    ### PM Voice
    proc voice_msg {nick uhost hand text} {
        set chan [lindex [split $text] 0]

        if {![matchstr "#*" $chan]} {
            putserv "PRIVMSG $nick :[::msgcat::mc pm.error.syntax] voice <#chan> <nick>"
            return 0
        }

        if {![validchan $chan]} {
            putserv "PRIVMSG $nick :[format [::msgcat::mc bot.not.onchan] $chan]"
            return 0
        }

        if {![matchattr $hand o|o $chan]} {
            putserv "PRIVMSG $nick :[format [::msgcat::mc error.no.access] $nick]"
            return 0
        }

        set target [lindex [split $text] 1]

        if {$target eq ""} {
            putserv "PRIVMSG $nick :[::msgcat::mc pm.error.syntax] voice <#chan> <nick>"
            return 0
        }

        if {![onchan $target $chan]} {
            putserv "PRIVMSG $nick :[format [::msgcat::mc not.on.chan] $target $chan]"
            return 0
        }

        pushmode $chan +v $target
        return 0
    }

    ### PM Devoice
    proc devoice_msg {nick uhost hand text} {
        set chan [lindex [split $text] 0]

        if {![matchstr "#*" $chan]} {
            putserv "PRIVMSG $nick :[::msgcat::mc pm.error.syntax] devoice <#chan> <nick>"
            return 0
        }

        if {![validchan $chan]} {
            putserv "PRIVMSG $nick :[format [::msgcat::mc bot.not.onchan] $chan]"
            return 0
        }

        if {![matchattr $hand o|o $chan]} {
            putserv "PRIVMSG $nick :[format [::msgcat::mc error.no.access] $nick]"
            return 0
        }

        set target [lindex [split $text] 1]

        if {$target eq ""} {
            putserv "PRIVMSG $nick :[::msgcat::mc pm.error.syntax] devoice <#chan> <nick>"
            return 0
        }

        if {![onchan $target $chan]} {
            putserv "PRIVMSG $nick :[format [::msgcat::mc not.on.chan] $target $chan]"
            return 0
        }

        pushmode $chan -v $target
        return 0
    }

    ### PM Unban
    proc unban_msg {nick uhost hand text} {
        set chan [lindex [split $text] 0]

        if {![matchstr "#*" $chan]} {
            putserv "PRIVMSG $nick :[::msgcat::mc pm.error.syntax] unban <#chan> <nick>"
            return 0
        }

        if {![validchan $chan]} {
            putserv "PRIVMSG $nick :[format [::msgcat::mc bot.not.onchan] $chan]"
            return 0
        }

        if {![matchattr $hand o|o $chan]} {
            putserv "PRIVMSG $nick :[format [::msgcat::mc error.no.access] $nick]"
            return 0
        }

        set banmask [lindex [split $text] 1]

        if {$banmask eq ""} {
            putserv "PRIVMSG $nick :[::msgcat::mc pm.error.syntax] unban <#chan> <mask>"
            return 0
        }

        if {![isban $banmask $chan]} {
            putserv "PRIVMSG $nick :[format [::msgcat::mc not.ban.mask] $banmask $chan]"
            return 0
        }

        killchanban $chan $banmask
        pushmode $chan -b $banmask
        putserv "PRIVMSG $nick :[format [::msgcat::mc ban.removed] $banmask $chan]"
        return 0
    }

    ### PM Banlist
    proc banlist_msg {nick uhost hand text} {
        set chan [lindex [split $text] 0]

        if {![matchstr "#*" $chan]} {
            putserv "PRIVMSG $nick :[::msgcat::mc pm.error.syntax] unban <#chan> <nick>"
            return 0
        }

        if {![validchan $chan]} {
            putserv "PRIVMSG $nick :[format [::msgcat::mc bot.not.onchan] $chan]"
            return 0
        }

        if {![matchattr $hand o|o $chan]} {
            putserv "PRIVMSG $nick :[format [::msgcat::mc error.no.access] $nick]"
            return 0
        }

        set cbans [banlist $chan]
        set cbans [lsearch -all -inline -not -index 1 $cbans "EXTBAN"]
        if {[llength $cbans] == 0} {
            putserv "PRIVMSG $nick :[format [::msgcat::mc banlist.empty] $chan]"
            return 0
        }

        set filename [string trim "$chan" #]_banlist.txt
        set bancount [llength $cbans]

        set blist [open $filename "w"]
        set i 1
        puts $blist "[format [::msgcat::mc banlist.open] $chan $bancount]"
        puts $blist ""

        foreach botban $cbans {
            set banmask [lindex $botban 0]
            set reason [lindex $botban 1]
            if {[isbansticky $banmask $chan]} {
                set freason "$reason \(sticky\)"
            } else {
                set freason "$reason"
            }
            set tstamp [lindex $botban 3]
            set date [clock format $tstamp -format "%d/%m/%Y - %H:%M:%S"]
            set creator [lindex $botban end]
            puts $blist "\[${i}\] [format [::msgcat::mc banlist.format] $banmask $freason $creator $date]"
            puts $blist ""
            incr i
        }

        puts $blist "[format [::msgcat::mc banlist.end] $chan]"
        puts $blist ""
        puts $blist "[format [::msgcat::mc pm.banlist.explain] $::botnick] unban <banmask>"
        close $blist

        if {[catch {
            set result [exec cat $filename | {*}$::cmgmt::upCommand]
        } err]} {
            putserv "PRIVMSG $nick :[format [::msgcat::mc banlist.upload.fail] $err]"
            file delete $filename
            return 0
        }

        putserv "PRIVMSG $nick :[format [::msgcat::mc banlist.url] $chan $result]"
        file delete $filename
        return 0
    }

    ### PM Auto add
    proc autoban_msg {nick uhost hand text} {
        set chan [lindex [split $text] 0]

        if {![matchstr "#*" $chan]} {
            putserv "PRIVMSG $nick :[::msgcat::mc pm.error.syntax] autoadd <#chan> <on/off/status>"
            return 0
        }

        if {![validchan $chan]} {
            putserv "PRIVMSG $nick :[format [::msgcat::mc bot.not.onchan] $chan]"
            return 0
        }

        if {![matchattr $hand o|o $chan]} {
            putserv "PRIVMSG $nick :[format [::msgcat::mc error.no.access] $nick]"
            return 0
        }

        set option [lindex [split $text] 1]

        switch $option {
            on {
                if {[channel get $chan addBans]} {
                    putserv "PRIVMSG $nick :[format [::msgcat::mc autoadd.enabled] $chan]"
                    return 0
                } else {
                    channel set $chan +addBans
                    putserv "PRIVMSG $nick :[format [::msgcat::mc autoadd.enable] $chan]"
                    return 0
                }
            }

            off {
                if {![channel get $chan addBans]} {
                    putserv "PRIVMSG $nick :[format [::msgcat::mc autoadd.disabled] $chan]"
                    return 0
                } else {
                    channel set $chan -addBans
                    putserv "PRIVMSG $nick :[format [::msgcat::mc autoadd.disable] $chan]"
                    return 0
                }
            }

            status {
                if {[channel get $chan addBans]} {
                    set turned "enabled"
                } else {
                    set turned "disabled"
                }
                putserv "PRIVMSG $nick :[format [::msgcat::mc autoadd.status] $turned $chan]"
                return 0
            }

            default {
                putserv "PRIVMSG $nick :[::msgcat::mc pm.error.syntax] autoadd <#chan> <on/off/status>"
                return 0
            }
        }
        return 0
    }

    ### PM Opcmds
    proc opcmds_msg {nick uhost hand text} {
        set chan [lindex [split $text] 0]

        if {![matchstr "#*" $chan]} {
            putserv "PRIVMSG $nick :[::msgcat::mc pm.error.syntax] opcmds <#chan>"
            return 0
        }

        if {![validchan $chan]} {
            putserv "PRIVMSG $nick :[format [::msgcat::mc bot.not.onchan] $chan]"
            return 0
        }

        if {![matchattr $hand o|o $chan]} {
            putserv "PRIVMSG $nick :[format [::msgcat::mc error.no.access] $nick]"
            return 0
        }

        putserv "PRIVMSG $nick :[::msgcat::mc msg.cmgmt.cmds] "
        return 0
    }

    # ---------- DON'T TOUCH UNLESS YOU KNOW WHAT YOU'RE DOING ---------- #
    # ----------
    # Auto add bans
    # ----------
    proc abans {nick uhost hand chan mode target} {
        # putlog "DEBUG autobans: nick=$nick chan=$chan mode=$mode target=$target"
        set banReason "[::msgcat::mc ban.reason] \(auto-added\)"

        if {$nick ne "$::botnick" && $nick ni $::cmgmt::noAddNicks} {
            foreach pmask $::cmgmt::protectMasks {
                if {[matchstr $pmask $target] || [matchstr $target $pmask]} {
                    pushmode $chan -b $target
                    flushmode $chan
                    return 0
                }
            }

            foreach nmask $::cmgmt::noAddMasks {
                if {[matchstr $nmask $target] || [matchstr $target $nmask]} {
                    pushmode $chan -b $target
                    flushmode $chan
                    return 0
                }
            }

            foreach user [userlist] {
                if {[matchattr $user mno|mno $chan]} {
                    foreach host [getuser $user HOSTS] {
                        if {[matchstr $target $host] || [matchstr $host $target]} {
                            pushmode $chan -b $target
                            flushmode $chan
                            return 0
                        }
                    }
                }
            }

            if {![channel get $chan addBans]} {
                return 0
            }

            # We also need to deal with the addition of extbans, since we don't deal with them internally
            if {[matchstr "~*" $target] && ![isban $target $chan]} {
                newchanban $chan $target $nick EXTBAN 0 sticky
                return 0
            } else {
                newchanban $chan $target $nick $banReason 0
                putserv "NOTICE @$chan :[format [::msgcat::mc auto.added] $target $chan]"
                return 0
            }
        }
        return 0
    }

    proc rbans {nick uhost hand chan mode target} {
        # putlog "DEBUG autobans: nick=$nick chan=$chan mode=$mode target=$target"
        if {![channel get $chan addBans]} {
            return 0
        }

        if {$nick ne "$::botnick"} {
            if {[matchstr "~*" $target] && [isban $target $chan]} {
                killchanban $chan $target
                return 0
            }
        }
    }



    # Lets check for existing extbans and add them to our ban list
    # and make them sticky so the bot doesn't remove them
    bind cron * "*/5 * * * *" ::cmgmt::addextbans
    proc addextbans {minute hour day month weekday} {
        # putlog "Adding existing extbans to banlist"
        foreach chan [channels] {
            foreach cban [chanbans $chan] {
                set mask [lindex [split $cban] 0]
                if {[matchstr "~*" $mask] && ![isban $mask $chan]} {
                    newchanban $chan $mask $::botnick EXTBAN 0 sticky
                }
            }
        }
        return 0
    }

    putlog "-= $::cmgmt::scriptName by $::cmgmt::scriptAuthor loaded =-"
}