###
### vim:ts=8 ai si sw=4 sta sm:
### $Id: x.irc,v 1.3 2005/08/01 19:14:01 sec Exp sec $
### Complete user registration including autoop
###

alias x.help {
	echo *** This is a Complete User registration script
	echo *** /remove <nick> - Remove registration of <Nick>
	echo *** 
	echo *** /saveconf - Save user list to $x.save
	echo *** /loadconf - Load user list to $x.save
	echo *** 
	echo *** The filename is constructed from \$net which should be set
	echo *** before loading this script.
	echo *** 
	echo *** The random delay is: rnd($aop.trnd)+\$aop.toff with aop.trnd=$aop.trnd, aop.toff=$aop.toff
}

if ([$aop.toff]==[]) {assign aop.toff 25}
if ([$aop.trnd]==[]) {assign aop.trnd 15}
if ([$net]==[])      {assign net default}
^eval assign x.save .irc/$net\.x

# 1 - register(nick) Laut
# 2 - successful reg'ed
# 3 - Mode (domode.doit)- debug
# 4 - Load/save

alias info if (index($0 $info) + 1){xecho -window muell !!$0 $1- }
eval if (![$info]){assign info 2 3}

/alias rl load x.irc
#load fkey.irc
^assign _id °°°

if ([$x.loaded]!=[1]){
	set load_path $LOAD_PATH:~/.irc/work/
	window new name muell hide
	echo $_id Savefile set to $x[save]
}

alias set.on ^assign.sec poof.$0 $1 $($1);^set.sec $1 $2-
alias set.off ^set.sec $(poof.$0);^assign -poof.$0;if ([$1]){set.off $1-}

# Anick (Actual)
# Snick (Store)
# Pnick (Print)

# Nick!User@Host ->
alias uho ^assign FUNCTION_RETURN $mid($index(! $0) 60 $0)
alias nickonly ^assign FUNCTION_RETURN $left($index(! $0) $0)

# Anick ->
alias regdata ^assign FUNCTION_RETURN $(reg.$encode($tolower($0)).$1)
alias Sdata ^assign FUNCTION_RETURN $(dat.$(reg.$encode($tolower($0)).n).$1)
alias Snick ^assign FUNCTION_RETURN $(reg.$encode($tolower($0)).n)
alias where ^assign FUNCTION_RETURN $(reg.$encode($tolower($0)).u)
alias Pnick ^assign FUNCTION_RETURN $(dat.$(reg.$encode($tolower($0)).n).ni)
# Snick -> Pnick
alias StoPnick ^assign FUNCTION_RETURN $(dat.$0.ni)

alias goodnick {
	^assign tt $Snick($0);
	if ([$[1]tt]==[_]) {
		assign FUNCTION_RETURN $0
	}{
		^assign tt $StoPnick($tt)
		if (match($0 $tt)){
			^assign FUNCTION_RETURN $word($match($0 $tt) _internal_error_ $tt)
		}{
			^assign FUNCTION_RETURN $0:$word(0 $tt)
		}
	}
}

/alias person ^assign FUNCTION_RETURN $(goodnick($0))$(where($0))

# Nick !User@Host ->
/alias testreg {
    if ([$(reg.$encode($tolower($0)).u)]==[$1]){
		info 0 Already Registerd: $Pnick($0)
	}{
		^assign reg.$encode($tolower($0)).n $register($0$1)
		^assign reg.$encode($tolower($0)).u $1
		if ([$([1]reg.$encode($tolower($0)).n)]!=[_]) {
			info 2 Sucessfully registerd $person($0)
		}{
			info 1 Not able to register $person($0)
		}
	}
}

# Nick!User@Host ->
/alias register {
   ^assign -uu
   foreach dat tt {
	   if (![$uu]){
		   if (rmatch($0 $(dat.$(tt).id))) {
		   ^assign uu $tt}
		}
	}
   ^assign -tt
   if (![$uu]){
		echo *** register for $0 failed
		^assign uu _zz
	}
   ^assign FUNCTION_RETURN $uu
}

# Anick ->
/alias remove {
       ^assign tt $encode($tolower($0))
       foreach reg.$tt uu {
         ^assign -reg.$(tt).$uu}
       info 1 Removed $0
       if ([$1]) {remove $1-}
       ^assign -tt
       ^assign -uu}

/alias clean foreach reg tt {if ([$([1]reg.$(tt).n)]==[_]) {remove $decode($tt)}}

# ------------------------------- On's

/on #-nick 21 "*" {
	assign reg.$encode($tolower($1)).u $(reg.$encode($tolower($0)).u)
	assign reg.$encode($tolower($1)).n $(reg.$encode($tolower($0)).n)
	info 1 changed $0 to $1
	remove $0
}

/on #-RAW_IRC 21 "*!* *" {
	testreg $nickonly($0) $uho($0)
}

/on #-join 21 "*" {
	if ([$N]==[$0]) {
		info 1 Not aop'ing myself
	}{
		if (rmatch($1 $Sdata($0 A))) {
			echo $_id $goodnick($0) Aopped on $1
			@ aop.time = rand($aop.trnd) + aop.toff
			timer $aop.time /mgop $1 $0
		}{
			info 1 $goodnick($0) Wouldnt aopped on $1
		}
	}
}

/on #-signoff 21 "*" {
	remove $0
}
alias mgop {
	if ([$ischanop($1 $0)]) {
		echo *** $1 is already op on $0
	} {
		mode $0 +o $1
	}
}

## /on ^notify_signon * userhost $0 -cmd handle_signon $$0-
## /alias handle_signon {
##        testreg $0 !$3@$4
##        if ([$2]==[-]) {
##          echo *** Signon by $person($0) detected}{
##          echo *** Signon by $person($0) decteted (away)}}
## 
## /on ^notify_signoff * {
##      echo *** Signoff by $person($0) detected
##      remove $0}

#------------------------------------------------------- Output mod

# For use with timestamp
alias _.onmsgprnt {
	lecho [4,5$goodnick($0)] $1- $ts.time($encode(msg))
}

alias _.onpublicprt {
        if (!match($1 $channel.name)) {
                echo <$goodnick($0)> $2- $ts.time($encode($tolower($1)))
        }{
                echo $[9]1 <$goodnick($0)> $2- $ts.time($encode($tolower($1)))
        }
}

alias _.onactionprt {
	if (!match($1 $channel.name)) {
		if ([$1]==[$C]){
			echo * $goodnick($0) $2- $ts.time($encode($tolower($1)))
		}{
			if ([$1]==[$N]){
				lecho *> $goodnick($0) $2- $ts.time($encode($tolower($1)))
			}{
				echo * $goodnick($0):$1 $2- $ts.time($encode($tolower($1)))
			}
		}
	}{
		echo $[9]1 * $goodnick($0) $2- $ts.time($encode($tolower($1)))
	}
}
#------------------------------------------------------- Load/save
alias cut1 {
  ^assign tt $index(: $0-)
  ^assign FUNCTION_RETURN $left($tt $0-)
  @ tt = tt + 1
  ^assign -more
  ^assign more $mid($tt 200 $0-)
}

#Snick Pnick:Id-strings:[specialid:specialaction:] ->
alias adddata {
  assign dat.$0.ni $cut1($1-)
  assign dat.$0.id $cut1($more)
  adddata_more $0 $more
}

#Snick specialid:specialaction: ->
alias adddata_more {
	if ([$1]) {
		assign dat.$0.$cut1($1-) $cut1($more);adddata_more $0 $more
	}{
		foreach dat.$0 tt {
			info 4 LOAD : DAT.$0.$tt = $(dat.$0.$tt)
		}
	}
}

#-----------------------------------------------------------------
# Save Config
# 
alias saveconf {
	^set.on 3 INPUT_PROMPT
	exec -name save_it cat>$x.save
	foreach dat uu {
		^eval set INPUT_PROMPT [Saving:$$[8]uu]$notword(1 $poof.3) 
		save.line $uu
    }
	^exec -HUP %save_it
	^set.off 3
}

alias save.line {
	save.special $0
	^msg %save_it adddata $0 $(dat.$0.ni):$(dat.$0.id):$more
}

alias save.special {
	^assign -more
	foreach dat.$0 tt {
		if ([$tt]!=[id] && [$tt]!=[ni]) {
			^assign more $(more)$tt:$(dat.$0.$tt):
		}
    }
}
#-----------------------------------------------------------------
alias cleanconf {
	foreach dat uu {
		foreach dat.$uu tt {
			^assign -dat[$uu][$tt]
		}
	}
}
alias loadconf load $x.save

#-----------------------------------------------------------------
# Add a Person by Nickname
#
alias plusnick {
  userhost $0 -cmd plusnick.help $$0-
  if ([$1]) {
	plusdata_more $toupper($strip([]{}|\- $0)) $1-
  }
}
alias plusnick.help plusnick.real $toupper($strip([]{}|\- $0)) $0 *!$3@$4

alias plusnick.real {
  ^assign.add dat.$0.ni $1
  ^assign.add dat.$0.id $2
  info 4 added $person($1)
  remove $1
}

alias plusdata {
  ^assign.add dat.$Snick($0).$1 $2
  info 4 added $1 $2 to $person($0)
}

alias plusdata_more {
  ^assign.add dat.$0.$1 $2
  info 4 added $1 $2 to $0
}

alias remnick {
	foreach dat.$0 tt {
		^assign -dat[$0][$tt]
	}
}
#-----------------------------------------------------------------

alias lreg {
	foreach reg tt {
		foreach reg.$tt uu {
			echo *** reg.$decode($(tt)).$uu = $(reg.$(tt).$uu)
		}
	}
	^assign -tt
	^assign -uu
}

alias lr foreach reg tt {
	echo *** Registered: $person($decode($tt))
	^assign -tt
}

alias lir echo *** Registered is : $0 as $person($0)

alias lid {lir $0;assign dat.$Snick($0).}

#Goodassign
alias assign.sec {if ([$1]) {assign $0-}{assign -$0}}
alias assign.add {assign $0 $($0) $1-}
alias assign.rem {assign.sec $0 $notword($match($1 $($0)) $($0))}
alias set.sec {if ([$1]) {set $0-}{set -$0}}

if ([$x.loaded]!=[1]){
	loadconf
}


### ------------------------------------------------------------------------
### Message Logging.
###
if ([$x.loaded]!=[1]){
	window new name log level none logfile .irc/$net\.log log on hide 
}
alias lecho {
	echo $0-
	xecho -window log $time() $0-
}

alias _.onsendactionprt {
	if (!match($0 $channel.name)) {
		if ([$0]==[$C]){
			echo * ${N} $1- $ts.time($encode($tolower($0)))
		}{
			lecho >$0> * ${N} $1-
		}
	}{
		echo $[9]0 * ${N} $1- $ts.time($encode($tolower($0)))
	}
}

alias _.onsendmsgprnt lecho -> [$0] $1-

### ------------------------------------------------------------------------
assign x.loaded 1