#
# Comments begin with # and blank lines are ignored. 
# No additional options are permitted.

# Jabber connection information
#
JabberServer   YOUR.JABBER.SERVER
JabberPort     5223
JabberTLS      1
JabberResource ijbridge
JabberUser     VALIDJABBERUSERID
JabberPassword VALIDJABBERPASSWORD

# Details for the Jabber conference room to join to.
#
Conference      [email protected]
ConferenceNick  ijchain

# IRC connection details
#
IrcServer      IRC.SERVER.NAME
IrcPort        6667
IrcTLS         1
IrcUser        IRCNICK
IrcChannel     #IRCCHANNEL
SuppressTraffic 1

# Values for LiberaChat
# IrcServer       irc.libera.chat
# IrcPort         6697
# IrcTLS          1
# IrcUser         Ijchain
# IrcChannel      #tcl

# FreeNode restricts PRIVMSG to identified users.
# Provide your IrcUser nick's pasword for use in identifying this
# client to FreenNode's nickserv.
# On LiberaChat, set this to the empty string if joining as an
# unidentified user
IrcNickPasswd  IRCNICKSERVPASSWORD
#
# If you want to maintain a running statistics count between invocations
# then specify a file path to maintain the counters. If this is an empty
# string then no file will be used.
#
StatisticsFile ""

#
# -------------------------------------------------------------------------
# See the file "license.terms" for information on usage and redistribution
# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
# -------------------------------------------------------------------------

package require jlib;                   # jabberlib
catch {package require tls;}
package require browse;                 # jabberlib
package require muc;                    # jabberlib
package require wrapper;                # jabberlib
package require sha1;                   # tcllib
package require log;                    # tcllib
package require irc 0.4;                # tcllib

namespace eval client {}

namespace eval ::ijbridge {

    variable version 1.1.1


    # This array MUST be set up by reading the configuration file. The
    # member names given here define the settings permitted in the
    # config file.
    # This script will not work by default - you MUST provide suitable
    # connection details.
    #
    variable Options
    if {![info exists Options]} {
        array set Options {
            JabberServer     {}
            JabberPort       5222
            JabberUser       {}
            JabberPassword   {}
            JabberResource   ijbridge
            JabberTLS        0
            Conference       {}
            ConferenceNick   {}

            IrcServer        irc.freenode.net
            IrcPort          6667
            IrcTLS           0
            IrcUser          {}
            IrcChannel       {}
            SuppressTraffic  0
            IrcNickPasswd    {}
            StatisticsFile   {}
            NotificationPort {}
            ColorsFile       {}
        }
    }

    # State variable used in rate-limiting communications with IRC.
    variable Limit
    if {![info exists Limit]} {
        array set Limit {}

#	to your jabber server, then you would give 'connect localhost 5222'
#	to set up this connection.
#
proc ::ijbridge::connect {{server {}} {port {}}} {
    variable Options
    variable conn
    array set conn {}

    # If roster is unset this is a new connection.
    if {![info exists conn(roster)]} {
        log::log debug "Creating new jabber client instance"
        set conn(roster) [roster::roster [namespace origin OnRoster]]
        set conn(jabber) [jlib::new $conn(roster) \
                              [namespace origin OnClient] \
                              -iqcommand       [namespace origin OnIq] \

        if {$server == {}} { set server $Options(JabberServer) }
        if {$port == {}} { set port $Options(JabberPort) }
        set conn(server) $server
        set conn(port) $port
    }

    set socketcmd socket
    if {$Options(JabberTLS)} {
	set socketcmd tls::socket
    }
    set conn(sock) [$socketcmd $conn(server) $conn(port)]
    $conn(jabber) setsockettransport $conn(sock)
    $conn(jabber) openstream $Options(JabberServer) \
        -cmd [namespace current]::OnConnect -socket $conn(sock)

    return
}

# ijbridge::disconnect --

#
#	Called when the Jabber stream is initialised. Here we authenticate
#	with the Jabber server.
#
proc ::ijbridge::OnConnect {token args} {
    variable Options
    variable conn

    log::log debug "OnConnect $token $args"
    array set info $args
    set conn(info) $args
    set conn(id) [$token send_auth \
                      $Options(JabberUser) $Options(JabberResource) \
                      [namespace origin OnLogin] \
                      -digest [sha1::sha1 $info(id)$Options(JabberPassword)]]

                    lappend c [list query [list xmlns $iqns node $iqnode] 0 {} $p]
                    set r [list iq [list xmlns jabber:client type result \
                                        id $a(-id) to $a(-from) from $a(-to)] 0 {} $c]
                }
                default {
                    set r [IqError $iqns feature-not-implemented \
                               $a(-id) $a(-to) $a(-from) cancel 501]
                }
            }
        }
        jabber:iq:version {
            variable version
            lappend p [list name {} 0 "IRC-Jabber Bridge" {}]
            lappend p [list version {} 0 $version {}]
            lappend p [list os {} 0 "Tcl/[info patchlevel]" {}]

    jlib::splitjid $a(-from) room nick
    log::log debug [info level 0]
    if {[jlib::jidequal $room $Options(Conference)]} {
        log::log debug "message from $room, user $nick"
        switch -exact -- $type {
            available {
                # Ignore the presence state change messages
                if {$a(-from) ni $MucUserList} {
		    if {! $Options(SuppressTraffic)} {
			xmit "PRIVMSG $::client::channel :\001ACTION $nick has joined the jabber conference\001"
		    }
                    lappend MucUserList $a(-from)
                }
            }
            unavailable {
		if {! $Options(SuppressTraffic)} {
		    xmit "PRIVMSG $::client::channel :\001ACTION $nick left the jabber conference\001"
		}
                if {[set ndx [lsearch -exact $MucUserList $a(-from)]] != -1} {
                    set MucUserList [lreplace $MucUserList $ndx $ndx]
                }
            }
        }
    }
}

        for {set n 0} {$n < 32} {incr n} {
            if {$n == 9 || $n == 10 || $n == 13} continue
            lappend xmlmap [format %c $n] [format "&#x%x;" $n]
        }
    }

    # Eliminate known bridge prefixes (ircbridge is a webchat to irc bridge)
    if { $who in {azbridge webchain wubchain ircbridge ischain} } {



        regexp {^<(.*?)> (.*)$}  $msg -> who msg
        set emote [regexp {^\*{1,3} (\w+) (.*)$} $msg -> who msg]
    }

    # Are they speaking to the bot? If so look for bot commands.
    if {[string match -nocase "${::client::nick}\[:,;. |\]*" $msg]} {
        set n [string length ${::client::nick}]

        }
        Pop args
    }
    if {[llength $args] != 1} {
        return -code error "wrong \# args:\
            should be \"send ?option value? message\""
    }
    if { $opts(-id) eq "" } {
        set opts(-id) $conn(id)
    }
    if { $opts(user) eq "" } {
        set opts(user) $Options(Conference)
        set opts(-type) groupchat
    }

    log::log debug "send: [lindex $args 0]"
    eval [linsert [array get opts -*] 0 $conn(jabber) \
              send_message $opts(user) -body [lindex $args 0]]
}

# ijbridge::xmit --
#
#	This is where we send messages to the IRC channel. IRC requires
#	rate limiting. A client can be kicked for sending too much in
#	too short a period so here we deal with this.
#
proc ::ijbridge::xmit {str} {
    variable Options
    variable Limit
    # if we are over the sending limit just push line into the queue

    # if we are over the line limit kick off the queued sends
    if { $Limit(lines) > 4 } {
        ::log::log info "flood started"
        lappend Limit(queue) $str
        after 1000 [namespace origin XmitFromQueue]
        return
    }
    $::client::cn send $str
}

# ijbridge::XmitFromQueue --
#
#	If we had to limit messages sent from 'xmit' then we handle the
#	queued messages from here on a timer.
#
proc ::ijbridge::XmitFromQueue {} {
    variable Options
    variable Limit
    # return if the queue is empty
    if { [string length [set str [lindex $Limit(queue) 0]]] < 1 } {
        set Limit(last) 0
        ::log::log info "flood ended"
        return
    }
    set Limit(queue) [lreplace $Limit(queue) 0 0]
    ::log::log debug "sending from queue"
    $::client::cn send $str
    # send next line
    after 1200 [namespace origin XmitFromQueue]
}

# ijbridge::Pop --
#
#	Utility function used in option processing.

	::log::log notice "UsersOnline [msg]"
	set users [split [string map {@ "" % "" + ""} [string trim [msg]]] " "]
	foreach bridge {ircbridge azbridge ijbridge ijchain} {
	    set users [lsearch -all -inline -exact -not $users $bridge]
	}
        foreach u $users {lappend users_tmp $u}
    }

    $cn registerevent 366 {
        # End of NAMES list
        # Copy the new user list to the main list.
        variable users_tmp
        if {[info exists users_tmp]} {
            set ::ijbridge::IrcUserList $users_tmp
            unset users_tmp

        } err]} { puts stderr $err }
    }

    $cn registerevent 333 {
        # topicinfo - a handy marker for 'we just joined a channel'
        # Ask Chanserv to op us.
        cmd-send "PRIVMSG Chanserv :op $::client::channel $::client::nick"
    }

    # WHOIS handling from Jabber user
    $cn registerevent 311 {set ::client::whois(realname) [msg];set ::client::whois(address) [additional]}
    $cn registerevent 312 {set ::client::whois(url) [msg]}
    $cn registerevent 319 {set ::client::whois(channels) [msg]}
    $cn registerevent 320 {set ::client::whois(status) [msg]}
    $cn registerevent 302 {set ::client::whois(host) [msg]}
    $cn registerevent 318 {
        variable ::client::whois

    }

    $cn registerevent defaultevent {
        switch -exact -- [action] {
            PONG {}
            KICK {
                #::ijbridge::send "[who] kicked someone \"[msg]\""
                ::log::log notice "[action]:[who]:[target]:[msg]"
            }
            MODE -
            default {
                ::log::log notice "[action]:[who]:[target]:[msg]"
            }
        }
    }

    $cn registerevent PRIVMSG {
        if {[catch {
            if { [string equal [target] $::client::channel] } {
                set emote 0
                set msg [msg]
                if { [string match "\001*\001" [msg]] } {
                    if { [regexp {^\001ACTION (.+)\001$} [msg] -> msg] } {
                        set emote 1
                    }
                }
                ijbridge::IrcToJabber [who] $msg $emote
            } elseif {[string equal [target] $::client::nick]} {
                ::ijbridge::BotCommand [who] [who] [msg]
            } else {
                log::log debug "[action]:[who]:[target]:[msg]"
            }
        } err]} { log::log notice $err }
    }

    $cn registerevent PART {
        variable ::ijbridge::IrcUserList
	if { [target] eq $::client::channel && [who] ne $::client::nick } {
	    set IrcUserList \
		    [lsearch -all -inline -exact -not $IrcUserList [who]]
	    ijbridge::send "*** [who] leaves"
	}

    }

    $cn registerevent JOIN {
        variable ::ijbridge::IrcUserList
	if {    [who] ni {ircbridge azbridge ijbridge ijchain} &&
		[who] ne $::client::nick } {
	    if { [who] ni $IrcUserList } {
		lappend IrcUserList [who]
	    }
	    ijbridge::send "*** [who] joins"
	}
    }

    $cn registerevent NICK {
        variable ::ijbridge::IrcUserList
	if { [who] eq $::client::nick } {
	    set ::client::nick [msg]
	} else {
	    set IrcUserList \
		    [lsearch -all -inline -exact -not $IrcUserList [who]]
	    if { [msg] ni $IrcUserList } {
		lappend IrcUserList [msg]
	    }
	    ijbridge::send "*** [who] is now known as [msg]"
	}
    }

    $cn registerevent QUIT {

	}
    }
}

# connect to the server and register

proc client::connect {cn server port} {
    variable ::ijbridge::Options
    variable ::ijbridge::Limit
    variable nick
    # set up variable for rate limiting
    array set Limit [list last [clock seconds] queue {} lines 0]
    ::log::log notice "Connecting to $server on port $port"
    if {[catch {$cn connect $server $port} err]} {
        ::log::log notice "Could not connect: $err"
        after 10000 [list [namespace current]::connect $cn $server $port]
        return
    }
    fconfigure [$cn socket] -encoding utf-8 -profile replace ;# We shall always be utf-8
    if {$Options(IrcTLS)} {
	tls::import [$cn socket]
    }
    $cn user $nick localhost domain "Tcl Jabber-IRC bridge"
    $cn nick $nick
    ping
    ::log::log notice "Connected to $server"
}

proc client::ping {} {

#::irc::config debug 0

# -------------------------------------------------------------------------

# ijbridge::ReadControl --
#
#	Reads commands from stdin and evaluates them. This permits
#	us to issue commands to the server while it is still
#	running. Suitable commands are ijbridge::presence and
#	ijbridge::say or ijbridge::xmit.
#
proc ::ijbridge::ReadControl {chan} {
    variable Control
    if {![info exists Control]} {set Control {}}
    if {[eof $chan]} {

    fileevent $chan readable \
        [namespace code [list NotificationGet $chan]]
}
proc ::ijbridge::NotificationGet {chan} {
    variable Options
    upvar #0 [namespace current]::$chan state
    if {[gets $chan line] != -1} {
        lassign $line len hash data
        set data [base64::decode $data]
        set check [md5::md5 -hex $data]
        if {[string length $data] != $len} {
            puts stderr "failed length check from $state(addr):$state(port)"
        } elseif {$check ne $hash} {
            puts stderr "failed checksum from $state(addr):$state(port)"
        } else {
            lassign $data user channel url title
            if {$channel eq [jid node $Options(Conference)] ||
		$channel eq $Options(IrcChannel)            ||
		$channel eq [string map [list "#" ""] $Options(IrcChannel)]} {
                BotSay $::client::channel \
                    "$user has created a new paste at $url \"$title\""
            } else {
                puts stderr "channel \"$channel\" ignored"
            }
        }
        NotificationClose $chan

    }

    # Connect to IRC
    client::create $ijbridge::Options(IrcServer) \
        $ijbridge::Options(IrcPort) \
        $ijbridge::Options(IrcUser) \
        $ijbridge::Options(IrcChannel)

    # Connect to Jabber.
    eval [linsert $args 0 ::ijbridge::connect]
    set ::ijbridge::statid [after 3600000 ::ijbridge::DumpStats]

    # Create the notification service port
    if {$ijbridge::Options(NotificationPort) ne {}} {
        ::ijbridge::NotificationStart

        } else {
            # Permit running as a Windows service.
            if {![info exists tcl_service]} {
                vwait ::forever
            }
        }
    }

    # Record the statistics to file
    ::ijbridge::DumpStats
}

if {!$tcl_interactive} {
    set r [catch [linsert $argv 0 Main] err]
    if {$r} {puts $errorInfo}
    exit $r
}