#!/usr/bin/perl -w
#
# Author: Nathan "i am not y2k compliant" Benson
#  Email: phuzz@phactor.org
#    URL: http://www.phactor.org/
#   Date: 01.19.1900
#
###################################################################
#
# tested using: kicq-0.3.0 and licq-0.75.2, on slackware 7.0
#
###################################################################
#
# this is a little script i whipped up to convert my kicq list
# to an licq list. i have no idea if this will work for anyone
# else (besides me), but hopefully it will be of some use to
# someone somewhere.  anyways, here is how you use it:
#
#
# ./kicq2licq.pl <UIN> <TEMPLATE>
#
# **NOTE** - TEMPLATE may be an existing Licq UIN.uin file:
#
#
# $ licq.kicqconvert 29690151 ~/.licq/users/1234567.uin
#
# or you may use this template (remove all leading #'s).
# copy from CUT line to CUT line, paste it into another
# file, and remove all the leading #'s (;
#
# don't uncomment them here, or you are in for hard times.
#
########### CUT ###############

#[user]
#History = 
#Groups.System = 
#Groups.User = 
#Ip = 
#Port = 
#NewUser = 
#NewMessages = 
#LastOnline = 
#Alias = 
#FirstName = 
#LastName = 
#Email1 = 
#Email2 = 
#City = 
#State = 
#PhoneNumber = 
#FaxNumber = 
#Address = 
#CellularNumber = 
#Zipcode = 
#Country = 
#Timezone = 
#Authorization = 
#HideEmail = 
#Age = 
#Gender = 
#Homepage = 
#BirthYear = 
#BirthMonth = 
#BirthDay = 
#Language1 = 
#Language2 = 
#Language3 = 
#CompanyCity = 
#CompanyState = 
#CompanyPhoneNumber = 
#CompanyFaxNumber = 
#CompanyAddress = 
#CompanyName = 
#CompanyDepartment = 
#CompanyPosition = 
#CompanyHomepage = 

########### CUT ###############
#
#
# if one were so inclined, they could do their entire list at
# once doing something like this:
#
# cd ~/.kde/share/apps/kicq/contacts
# for i in *.uin; do
#	UIN=`echo $i | cut -f1 -d.`
# 	/path/to/kicq2licq.pl $UIN /path/to/template
# done
#
# this script doesn't require you to blow away your current
# users.conf, it will rebuild it with the person you just added.
#
# i.e. - you have 1 person on your Kicq list, and 3 on your Licq
# list, and you run the script on your single Kicq user, the script
# should update your users.conf file to 4 users.  if you have no
# clue what i'm talking about, then you are out of luck.  it's 3
# a.m. and i haven't a clue either.  you can email me if you want
# i'll try and help.
#


use strict;


my ($licq_template, $kicq_user);


## make sure we have proper args
$kicq_user     = $ARGV[0] || die("usage: $0 <UIN> <template>\n");
$licq_template = $ARGV[1] || die("usage: $0 <UIN> <template>\n");



## let the fun begin
write_licq_list($kicq_user, $licq_template);


##
## this function will break the kicq user.uin list
## into a hash, break the licq template into
## a hash, then break the licq users.conf file into
## a hash, create a new users.conf (updated for the
## new user), and create a UIN.uin file in the users/
## directory with information from the kicq UIN.uin
## file
##

sub	write_licq_list()
{
	my ($kicq_uin, $licq_template) = @_;
	my ($output_file, $key, $value, %kicq_hash, %licq_hash, %conf_hash, $licq_conf);


	## change these if you have a weird install of
	## licq, or i'm a dork and screwed something
	## up.
	$licq_conf   = "$ENV{'HOME'}/.licq/users.conf";
	$output_file = "$ENV{'HOME'}/.licq/users/$kicq_uin.uin";


	## parse the kicq list (;
	%kicq_hash = parse_kicq_list($kicq_uin);


	## parse the licq template.
	%licq_hash = parse_licq_list($licq_template);


	## parse the users.conf file, and store it in a hash
	%conf_hash = parse_licq_conf();



	## if we already have an existing UIN.uin, lets die.
	die("$output_file exists exiting") if -e $output_file;


	## print basic headers for the UIN.uin file.
	open(OUT, ">$output_file");
	print(OUT "\n");
	print(OUT "[user]\n");


	## sort through all the licq template values
	## and see if we have a matching kicq key.
	## if we do, we take the value of what the
	## kicq user.uin file had for it.  if not
	## we just leave it blank.

	while	(($key, $value) = each(%licq_hash))
	{
		## we have a match.
		if (exists($kicq_hash{$key}))
		{
			print(OUT "$value = $kicq_hash{$key}\n");
		}

		## leave it blank.
		else
		{
			print(OUT "$value =\n");
		}
	}
	## close the output file
	close(OUT);



	## open the users.conf file now.
	open(CONF, ">$licq_conf");


	## we are adding one user at a time, so we
	## increment the value of NumOfUsers we got
	## from parse_licq_conf() by one.
	$conf_hash{'NumOfUsers'}++;


	# print normal users.conf header stuff.
	print(CONF "[users]\n");
	print(CONF "NumOfUsers = $conf_hash{'NumOfUsers'}\n");


	## sort through the rest of the keys and values
	## we pulled out of the users.conf, and put them
	## back into place.  NOTE - these aren't sorted
	## so you may get User10, then User2.  Licq does
	## not seem to care, so i don't either. (=

	while	(($key, $value) = each(%conf_hash))
	{
		## we printed this already, so lets skip it
		if ($key ne "NumOfUsers")
		{
			print(CONF "$key = $value\n");
		}
	}


	## this is the user we are wanting to add.
	## so we add this at the end of the list.
	print(CONF "User$conf_hash{'NumOfUsers'} = $kicq_uin\n");


	## close the users.conf file
	close(CONF);
		
		
	## all done.
	exit(1);
}


##
## this function will user read the users.conf
## file into a hash, skipping any newlines,
## comments or [user] type lines.
##
sub	parse_licq_conf()
{
	## change this to suit you.  this is where mine was.
	my ($licq_conf) = "$ENV{'HOME'}/.licq/users.conf";

	my (%conf_hash, $key, $value);


	## can't read it if it's not there.
	die("could not find your $licq_conf\n") if ! -e $licq_conf;


	## open the config file for reading
	open(CONF, $licq_conf);


	## read the whole config file.
	while	(<CONF>)
	{
		chomp; 


		## skip comments, [user] type stuff, and blank lines
		next if /^[#\[]|^$/;


		## split the line into 2 values
		($key, $value) = split(/ = /, $_);


		## create the hash element with the 2 values.
		$conf_hash{$key} = $value;
	}
	## close the config file.
	close(CONF);


	## return the hash we built.
	return(%conf_hash);
}


##
## this function just reads the kicq UIN.uin file,
## and creates a hash all the values we have set.
## this is done so later we can compare the licq
## keys, against these and see if we have any that
## are the same (as opposed to losing that info).
##

sub	parse_kicq_list()
{
	my ($kicq_file) = @_;
	my (%kicq_hash, $key, $value);


	## this is where my kicq UIN.uin files were stored,
	## change this if it is different for you.
	$kicq_file = "$ENV{'HOME'}/.kde/share/apps/kicq/contacts/$kicq_file.uin";


	## can't read it if it doesn't exist right?
	open(KICQ, $kicq_file) || die("couldn't open $kicq_file - $!\n");


	## read through all the entries in the UIN.uin file
	while	(<KICQ>)
	{
		chomp;	


		## skip comments, [user] type stuff, and blank lines
		next if /^[#\[]|^$/;


		## split the line into 2 values
		($key, $value) = split(/=/, $_);


		## make the key all lowercase, so we don't have to
		## worry about case issues with the licq hash.
		$key =~ tr/[A-Z]/[a-z]/;


		## create the hash element.
		$kicq_hash{$key} = $value;
	}
	## close the UIN.uin file.
	close(KICQ);


	## return the hash we built
	return(%kicq_hash);
}


##
## this function will just read the template
## specified on the command line, create a
## hash of all the keys (everything on the
## right side of the ='s are tossed).  so
## in the end we end up with this:
##
## $hash{lower_case_key} = Lower_Case_Key;
##

sub	parse_licq_list()
{
	my ($licq_file) = @_;
	my (%licq_hash, $key, $tmp_key, $value);


	## can't read it if it doesn't exist right?
	open(LICQ, $licq_file) || die("couldn't open $licq_file - $!\n");

	while	(<LICQ>)
	{
		chomp;	

		## skip comments, [user] type stuff, and blank lines
		next if /^[#\[]|^$/;


		## split the line into 2 values
		($key, $value) = split(/ = /, $_);


		## we store the key in a temp variable
		## because we are going to turn the key
		## to all lower case, and i don't know
		## if Licq would freak with that.

		$tmp_key = $key;


		## make the key all lowercase, so we don't have to
		## worry about case issues with the kicq hash.
		$key =~ tr/[A-Z]/[a-z]/;


		## since we don't have any real values (we discarded
		## everything on the right of the =), we will store
		## the unmodified (real key) name.
		$licq_hash{$key} = $tmp_key;

	}
	## close the template
	close(LICQ);


	## return the hash we built
	return(%licq_hash);
}
# EOF