/* OperServ core functions
 *
 * (C) 2003-2005 Anope Team
 * Contact us at info@anope.org
 *
 * Please read COPYING and README for further details.
 *
 * Based on the original code of Epona by Lara.
 * Based on the original code of Services by Andy Church. 
 * 
 * $Id$
 *
 */
/*************************************************************************/

#include "module.h"



int do_stats(User * u);
void get_operserv_stats(long *nrec, long *memuse);
void myOperServHelp(User * u);

extern MDE struct clone clonelist[CLONE_DETECT_SIZE];
extern MDE struct clone warnings[CLONE_DETECT_SIZE];

/**
 * Create the command, and tell anope about it.
 * @param argc Argument count
 * @param argv Argument list
 * @return MOD_CONT to allow the module, MOD_STOP to stop it
 **/
int AnopeInit(int argc, char **argv)
{
    Command *c;

    moduleAddAuthor("Anope");
    moduleAddVersion("$Id$");
    moduleSetType(CORE);

    c = createCommand("STATS", do_stats, is_services_oper, OPER_HELP_STATS,
                      -1, -1, -1, -1);
    moduleAddCommand(OPERSERV, c, MOD_UNIQUE);
    c = createCommand("UPTIME", do_stats, is_services_oper,
                      OPER_HELP_STATS, -1, -1, -1, -1);
    moduleAddCommand(OPERSERV, c, MOD_UNIQUE);

    moduleSetOperHelp(myOperServHelp);

    return MOD_CONT;
}

/**
 * Unload the module
 **/
void AnopeFini(void)
{

}


/**
 * Add the help response to anopes /os help output.
 * @param u The user who is requesting help
 **/
void myOperServHelp(User * u)
{
    if (is_services_oper(u)) {
        notice_lang(s_OperServ, u, OPER_HELP_CMD_STATS);
    }
}

/**
 * Count servers connected to server s
 * @param s The server to start counting from
 * @return Amount of servers connected to server s
 **/
int stats_count_servers(Server *s)
{
	int count = 1;
	
	while (s) {
		if (s->links)
			count += stats_count_servers(s->links);
		s = s->next;
	}
	
	return count;
}

/**
 * The /os stats command.
 * @param u The user who issued the command
 * @param MOD_CONT to continue processing other modules, MOD_STOP to stop processing.
 **/
int do_stats(User * u)
{
    time_t uptime = time(NULL) - start_time;
    char *extra = strtok(NULL, "");
    int days = uptime / 86400, hours = (uptime / 3600) % 24,
        mins = (uptime / 60) % 60, secs = uptime % 60;
    struct tm *tm;
    char timebuf[64];
	char buf[512];
	int buflen;

    if (extra && stricmp(extra, "ALL") != 0) {
        if (stricmp(extra, "AKILL") == 0) {
            int timeout;
            /* AKILLs */
            notice_lang(s_OperServ, u, OPER_STATS_AKILL_COUNT,
                        akills.count);
            timeout = AutokillExpiry + 59;
            if (timeout >= 172800)
                notice_lang(s_OperServ, u, OPER_STATS_AKILL_EXPIRE_DAYS,
                            timeout / 86400);
            else if (timeout >= 86400)
                notice_lang(s_OperServ, u, OPER_STATS_AKILL_EXPIRE_DAY);
            else if (timeout >= 7200)
                notice_lang(s_OperServ, u, OPER_STATS_AKILL_EXPIRE_HOURS,
                            timeout / 3600);
            else if (timeout >= 3600)
                notice_lang(s_OperServ, u, OPER_STATS_AKILL_EXPIRE_HOUR);
            else if (timeout >= 120)
                notice_lang(s_OperServ, u, OPER_STATS_AKILL_EXPIRE_MINS,
                            timeout / 60);
            else if (timeout >= 60)
                notice_lang(s_OperServ, u, OPER_STATS_AKILL_EXPIRE_MIN);
            else
                notice_lang(s_OperServ, u, OPER_STATS_AKILL_EXPIRE_NONE);
            if (ircd->sgline) {
                /* SGLINEs */
                notice_lang(s_OperServ, u, OPER_STATS_SGLINE_COUNT,
                            sglines.count);
                timeout = SGLineExpiry + 59;
                if (timeout >= 172800)
                    notice_lang(s_OperServ, u,
                                OPER_STATS_SGLINE_EXPIRE_DAYS,
                                timeout / 86400);
                else if (timeout >= 86400)
                    notice_lang(s_OperServ, u,
                                OPER_STATS_SGLINE_EXPIRE_DAY);
                else if (timeout >= 7200)
                    notice_lang(s_OperServ, u,
                                OPER_STATS_SGLINE_EXPIRE_HOURS,
                                timeout / 3600);
                else if (timeout >= 3600)
                    notice_lang(s_OperServ, u,
                                OPER_STATS_SGLINE_EXPIRE_HOUR);
                else if (timeout >= 120)
                    notice_lang(s_OperServ, u,
                                OPER_STATS_SGLINE_EXPIRE_MINS,
                                timeout / 60);
                else if (timeout >= 60)
                    notice_lang(s_OperServ, u,
                                OPER_STATS_SGLINE_EXPIRE_MIN);
                else
                    notice_lang(s_OperServ, u,
                                OPER_STATS_SGLINE_EXPIRE_NONE);
            }
            if (ircd->sqline) {
                /* SQLINEs */
                notice_lang(s_OperServ, u, OPER_STATS_SQLINE_COUNT,
                            sqlines.count);
                timeout = SQLineExpiry + 59;
                if (timeout >= 172800)
                    notice_lang(s_OperServ, u,
                                OPER_STATS_SQLINE_EXPIRE_DAYS,
                                timeout / 86400);
                else if (timeout >= 86400)
                    notice_lang(s_OperServ, u,
                                OPER_STATS_SQLINE_EXPIRE_DAY);
                else if (timeout >= 7200)
                    notice_lang(s_OperServ, u,
                                OPER_STATS_SQLINE_EXPIRE_HOURS,
                                timeout / 3600);
                else if (timeout >= 3600)
                    notice_lang(s_OperServ, u,
                                OPER_STATS_SQLINE_EXPIRE_HOUR);
                else if (timeout >= 120)
                    notice_lang(s_OperServ, u,
                                OPER_STATS_SQLINE_EXPIRE_MINS,
                                timeout / 60);
                else if (timeout >= 60)
                    notice_lang(s_OperServ, u,
                                OPER_STATS_SQLINE_EXPIRE_MIN);
                else
                    notice_lang(s_OperServ, u,
                                OPER_STATS_SQLINE_EXPIRE_NONE);
            }
            if (ircd->szline) {
                /* SZLINEs */
                notice_lang(s_OperServ, u, OPER_STATS_SZLINE_COUNT,
                            szlines.count);
                timeout = SZLineExpiry + 59;
                if (timeout >= 172800)
                    notice_lang(s_OperServ, u,
                                OPER_STATS_SZLINE_EXPIRE_DAYS,
                                timeout / 86400);
                else if (timeout >= 86400)
                    notice_lang(s_OperServ, u,
                                OPER_STATS_SZLINE_EXPIRE_DAY);
                else if (timeout >= 7200)
                    notice_lang(s_OperServ, u,
                                OPER_STATS_SZLINE_EXPIRE_HOURS,
                                timeout / 3600);
                else if (timeout >= 3600)
                    notice_lang(s_OperServ, u,
                                OPER_STATS_SZLINE_EXPIRE_HOUR);
                else if (timeout >= 120)
                    notice_lang(s_OperServ, u,
                                OPER_STATS_SZLINE_EXPIRE_MINS,
                                timeout / 60);
                else if (timeout >= 60)
                    notice_lang(s_OperServ, u,
                                OPER_STATS_SZLINE_EXPIRE_MIN);
                else
                    notice_lang(s_OperServ, u,
                                OPER_STATS_SZLINE_EXPIRE_NONE);
            }
            return MOD_CONT;
        } else if (!stricmp(extra, "RESET")) {
            if (is_services_admin(u)) {
                maxusercnt = usercnt;
                notice_lang(s_OperServ, u, OPER_STATS_RESET);
            } else {
                notice_lang(s_OperServ, u, PERMISSION_DENIED);
            }
            return MOD_CONT;
        } else if (stricmp(extra, "MEMORY") && stricmp(extra, "UPLINK")) {
            notice_lang(s_OperServ, u, OPER_STATS_UNKNOWN_OPTION, extra);
        }
    }
	
	if ((stricmp(extra, "MEMORY") != 0) && (stricmp(extra, "UPLINK") != 0)) {
	    notice_lang(s_OperServ, u, OPER_STATS_CURRENT_USERS, usercnt, opcnt);
    	tm = localtime(&maxusertime);
	    strftime_lang(timebuf, sizeof(timebuf), u, STRFTIME_DATE_TIME_FORMAT,
    	              tm);
	    notice_lang(s_OperServ, u, OPER_STATS_MAX_USERS, maxusercnt, timebuf);
    	if (days > 1) {
        	notice_lang(s_OperServ, u, OPER_STATS_UPTIME_DHMS,
            	        days, hours, mins, secs);
	    } else if (days == 1) {
    	    notice_lang(s_OperServ, u, OPER_STATS_UPTIME_1DHMS,
        	            days, hours, mins, secs);
	    } else {
    	    if (hours > 1) {
        	    if (mins != 1) {
            	    if (secs != 1) {
                	    notice_lang(s_OperServ, u, OPER_STATS_UPTIME_HMS,
                    	            hours, mins, secs);
	                } else {
    	                notice_lang(s_OperServ, u, OPER_STATS_UPTIME_HM1S,
        	                        hours, mins, secs);
            	    }
	            } else {
    	            if (secs != 1) {
	                    notice_lang(s_OperServ, u, OPER_STATS_UPTIME_H1MS,
    	                            hours, mins, secs);
        	        } else {
            	        notice_lang(s_OperServ, u, OPER_STATS_UPTIME_H1M1S,
                	                hours, mins, secs);
	                }
    	        }
        	} else if (hours == 1) {
            	if (mins != 1) {
                	if (secs != 1) {
                    	notice_lang(s_OperServ, u, OPER_STATS_UPTIME_1HMS,
                        	        hours, mins, secs);
	                } else {
    	                notice_lang(s_OperServ, u, OPER_STATS_UPTIME_1HM1S,
        	                        hours, mins, secs);
            	    }
	            } else {
    	            if (secs != 1) {
        	            notice_lang(s_OperServ, u, OPER_STATS_UPTIME_1H1MS,
            	                    hours, mins, secs);
                	} else {
                    	notice_lang(s_OperServ, u, OPER_STATS_UPTIME_1H1M1S,
                        	        hours, mins, secs);
	                }
    	        }
        	} else {
            	if (mins != 1) {
                	if (secs != 1) {
                    	notice_lang(s_OperServ, u, OPER_STATS_UPTIME_MS,
                        	        mins, secs);
	                } else {
    	                notice_lang(s_OperServ, u, OPER_STATS_UPTIME_M1S,
        	                        mins, secs);
            	    }
	            } else {
    	            if (secs != 1) {
        	            notice_lang(s_OperServ, u, OPER_STATS_UPTIME_1MS,
            	                    mins, secs);
                	} else {
                    	notice_lang(s_OperServ, u, OPER_STATS_UPTIME_1M1S,
                        	        mins, secs);
	                }
    	        }
        	}
		}
    }
	
	if (extra && ((stricmp(extra, "ALL") == 0) || (stricmp(extra, "UPLINK") == 0)) && is_services_admin(u)) {
		notice_lang(s_OperServ, u, OPER_STATS_UPLINK_SERVER, serv_uplink->name);
		buf[0] = '\0';
		buflen = 511; /* How confusing, this is the amount of space left! */
		if (uplink_capab & CAPAB_NOQUIT) {
			strncat(buf, " NOQUIT", buflen);
			buflen -= 7;
		}
		if (uplink_capab & CAPAB_TSMODE) {
			strncat(buf, " TSMODE", buflen);
			buflen -= 7;
		}
		if (uplink_capab & CAPAB_UNCONNECT) {
			strncat(buf, " UNCONNECT", buflen);
			buflen -= 10;
		}
		if (uplink_capab & CAPAB_NICKIP) {
			strncat(buf, " NICKIP", buflen);
			buflen -= 7;
		}
		if (uplink_capab & CAPAB_NSJOIN) {
			strncat(buf, " SSJOIN", buflen);
			buflen -= 7;
		}
		if (uplink_capab & CAPAB_ZIP) {
			strncat(buf, " ZIP", buflen);
			buflen -= 4;
		}
		if (uplink_capab & CAPAB_BURST) {
			strncat(buf, " BURST", buflen);
			buflen -= 6;
		}
		if (uplink_capab & CAPAB_TS5) {
			strncat(buf, " TS5", buflen);
			buflen -= 4;
		}
		if (uplink_capab & CAPAB_TS3) {
			strncat(buf, " TS3", buflen);
			buflen -= 4;
		}
		if (uplink_capab & CAPAB_DKEY) {
			strncat(buf, " DKEY", buflen);
			buflen -= 5;
		}
		if (uplink_capab & CAPAB_PT4) {
			strncat(buf, " PT4", buflen);
			buflen -= 4;
		}
		if (uplink_capab & CAPAB_SCS) {
			strncat(buf, " SCS", buflen);
			buflen -= 4;
		}
		if (uplink_capab & CAPAB_QS) {
			strncat(buf, " QS", buflen);
			buflen -= 3;
		}
		if (uplink_capab & CAPAB_UID) {
			strncat(buf, " UID", buflen);
			buflen -= 4;
		}
		if (uplink_capab & CAPAB_KNOCK) {
			strncat(buf, " KNOCK", buflen);
			buflen -= 6;
		}
		if (uplink_capab & CAPAB_CLIENT) {
			strncat(buf, " CLIENT", buflen);
			buflen -= 7;
		}
		if (uplink_capab & CAPAB_IPV6) {
			strncat(buf, " IPV6", buflen);
			buflen -= 5;
		}
		if (uplink_capab & CAPAB_SSJ5) {
			strncat(buf, " SSJ5", buflen);
			buflen -= 5;
		}
		if (uplink_capab & CAPAB_SN2) {
			strncat(buf, " SN2", buflen);
			buflen -= 5;
		}
		if (uplink_capab & CAPAB_TOKEN) {
			strncat(buf, " TOKEN", buflen);
			buflen -= 6;
		}
		if (uplink_capab & CAPAB_VHOST) {
			strncat(buf, " VHOST", buflen);
			buflen -= 6;
		}
		if (uplink_capab & CAPAB_SSJ3) {
			strncat(buf, " SSJ3", buflen);
			buflen -= 5;
		}
		if (uplink_capab & CAPAB_SJB64) {
			strncat(buf, " SJB64", buflen);
			buflen -= 6;
		}
		if (uplink_capab & CAPAB_CHANMODE) {
			strncat(buf, " CHANMODES=", buflen);
			buflen -= 11;
			strncat(buf, ircd->chanmodes, buflen);
			buflen -= strlen(ircd->chanmodes);
		}
		if (uplink_capab & CAPAB_NICKCHARS) {
			strncat(buf, " NICKCHARS=", buflen);
			buflen -= 11;
			strncat(buf, ircd->nickchars, buflen);
			buflen -= strlen(ircd->nickchars);
		}
		notice_lang(s_OperServ, u, OPER_STATS_UPLINK_CAPAB, buf);
		notice_lang(s_OperServ, u, OPER_STATS_UPLINK_SERVER_COUNT, stats_count_servers(serv_uplink));
	}
	
	if (extra && ((stricmp(extra, "ALL") == 0) || (stricmp(extra, "MEMORY") == 0)) && is_services_admin(u)) {
        long count, mem;

        notice_lang(s_OperServ, u, OPER_STATS_BYTES_READ,
                    total_read / 1024);
        notice_lang(s_OperServ, u, OPER_STATS_BYTES_WRITTEN,
                    total_written / 1024);

        get_user_stats(&count, &mem);
        notice_lang(s_OperServ, u, OPER_STATS_USER_MEM, count,
                    (mem + 512) / 1024);
        get_channel_stats(&count, &mem);
        notice_lang(s_OperServ, u, OPER_STATS_CHANNEL_MEM, count,
                    (mem + 512) / 1024);
        get_core_stats(&count, &mem);
        notice_lang(s_OperServ, u, OPER_STATS_GROUPS_MEM, count,
                    (mem + 512) / 1024);
        get_aliases_stats(&count, &mem);
        notice_lang(s_OperServ, u, OPER_STATS_ALIASES_MEM, count,
                    (mem + 512) / 1024);
        get_chanserv_stats(&count, &mem);
        notice_lang(s_OperServ, u, OPER_STATS_CHANSERV_MEM, count,
                    (mem + 512) / 1024);
        get_botserv_stats(&count, &mem);
        notice_lang(s_OperServ, u, OPER_STATS_BOTSERV_MEM, count,
                    (mem + 512) / 1024);
        get_operserv_stats(&count, &mem);
        notice_lang(s_OperServ, u, OPER_STATS_OPERSERV_MEM, count,
                    (mem + 512) / 1024);
        get_session_stats(&count, &mem);
        notice_lang(s_OperServ, u, OPER_STATS_SESSIONS_MEM, count,
                    (mem + 512) / 1024);
    }
    return MOD_CONT;
}

void get_operserv_stats(long *nrec, long *memuse)
{
    int i;
    long mem = 0, count = 0, mem2 = 0, count2 = 0;
    Akill *ak;
    SXLine *sx;

    if (CheckClones) {
        mem = sizeof(struct clone) * CLONE_DETECT_SIZE * 2;
        for (i = 0; i < CLONE_DETECT_SIZE; i++) {
            if (clonelist[i].host) {
                count++;
                mem += strlen(clonelist[i].host) + 1;
            }
            if (warnings[i].host) {
                count++;
                mem += strlen(warnings[i].host) + 1;
            }
        }
    }

    count += akills.count;
    mem += akills.capacity;
    mem += akills.count * sizeof(Akill);

    for (i = 0; i < akills.count; i++) {
        ak = akills.list[i];
        mem += strlen(ak->user) + 1;
        mem += strlen(ak->host) + 1;
        mem += strlen(ak->by) + 1;
        mem += strlen(ak->reason) + 1;
    }

    if (ircd->sgline) {
        count += sglines.count;
        mem += sglines.capacity;
        mem += sglines.count * sizeof(SXLine);

        for (i = 0; i < sglines.count; i++) {
            sx = sglines.list[i];
            mem += strlen(sx->mask) + 1;
            mem += strlen(sx->by) + 1;
            mem += strlen(sx->reason) + 1;
        }
    }
    if (ircd->sqline) {
        count += sqlines.count;
        mem += sqlines.capacity;
        mem += sqlines.count * sizeof(SXLine);

        for (i = 0; i < sqlines.count; i++) {
            sx = sqlines.list[i];
            mem += strlen(sx->mask) + 1;
            mem += strlen(sx->by) + 1;
            mem += strlen(sx->reason) + 1;
        }
    }
    if (ircd->szline) {
        count += szlines.count;
        mem += szlines.capacity;
        mem += szlines.count * sizeof(SXLine);

        for (i = 0; i < szlines.count; i++) {
            sx = szlines.list[i];
            mem += strlen(sx->mask) + 1;
            mem += strlen(sx->by) + 1;
            mem += strlen(sx->reason) + 1;
        }
    }


    get_news_stats(&count2, &mem2);
    count += count2;
    mem += mem2;
    get_exception_stats(&count2, &mem2);
    count += count2;
    mem += mem2;

    *nrec = count;
    *memuse = mem;
}