/**
 * Unbans a character from the given channel.
 *
 * @param chan The channel.
 * @param ssd  The source character, if any.
 * @param tsd  The target character. If no target character is specified, all characters are unbanned.
 * @retval HCS_STATUS_OK if the operation succeeded.
 * @retval HCS_STATUS_ALREADY if the target character is not banned.
 * @retval HCS_STATUS_NOPERM if the source character doesn't have enough permissions.
 * @retval HCS_STATUS_FAIL in case of generic failure.
 */
enum channel_operation_status channel_unban(struct channel_data *chan, const struct map_session_data *ssd, struct map_session_data *tsd)
{
	nullpo_retr(HCS_STATUS_FAIL, chan);

	if (ssd && chan->owner != ssd->status.char_id && !pc_has_permission(ssd, PC_PERM_HCHSYS_ADMIN))
		return HCS_STATUS_NOPERM;

	if (!chan->banned)
		return HCS_STATUS_ALREADY;

	if (!tsd) {
		// Unban all
		db_destroy(chan->banned);
		chan->banned = NULL;
		return HCS_STATUS_OK;
	}

	// Unban one
	if (!idb_exists(chan->banned, tsd->status.account_id))
		return HCS_STATUS_ALREADY;

	idb_remove(chan->banned, tsd->status.account_id);
	if (!db_size(chan->banned)) {
		db_destroy(chan->banned);
		chan->banned = NULL;
	}

	return HCS_STATUS_OK;
}

/**
 * Deletes a chat channel.
 *
 * @param chan The channel to delete
 */
void channel_delete(struct channel_data *chan)
{
	nullpo_retv(chan);

	if (db_size(chan->users) && !channel->config->closing) {
		struct map_session_data *sd;
		struct DBIterator *iter = db_iterator(chan->users);
		for (sd = dbi_first(iter); dbi_exists(iter); sd = dbi_next(iter)) {
			channel->leave_sub(chan, sd);
		}
		dbi_destroy(iter);
	}
	if (chan->banned) {
		db_destroy(chan->banned);
		chan->banned = NULL;
	}
	db_destroy(chan->users);
	if (chan->m) {
		map->list[chan->m].channel = NULL;
		aFree(chan);
	} else if (chan->type == HCS_TYPE_ALLY) {
		aFree(chan);
	} else if (!channel->config->closing) {
		strdb_remove(channel->db, chan->name);
	}
}

void mapreg_final(void)
{
	if( mapreg_dirty )
		script_save_mapreg();

	db_destroy(mapreg_db);
	db_destroy(mapregstr_db);
}

/**
 * Finalize PC Groups: free DBMaps and config.
 * @public
 */
void do_final_pc_groups(void)
{
	if (pc_group_db != NULL)
		db_destroy(pc_group_db);
	if (pc_groupname_db != NULL )
		db_destroy(pc_groupname_db);
	destroy_config();
}

static int channel_db_final(DBKey key, DBData *data, va_list ap)
{
	struct channel_data *cd = (struct channel_data *)db_data2ptr(data);
	ShowInfo("Channel System : Removing Channel %s from memory.\n", cd->name);
	db_destroy(cd->users_db);
	return 0;
}

/*
** function code
*/
void db_create() {

	/*if there is an old database table, get rid of it*/
	db_destroy();

	/* get a new table */
	db_functions = (DB_Table *) SafeMalloc(sizeof(DB_Table));

	/*set all function pointers to NULL, and each database can choose*/
	/*whatever ones they wanna implement and associate them*/

	db_functions->get_value = db_get_value;
	db_functions->put_value = db_put_value;
	db_functions->get_remoteness = db_get_remoteness;
	db_functions->put_remoteness = db_put_remoteness;
	db_functions->check_visited = db_check_visited;
	db_functions->mark_visited = db_mark_visited;
	db_functions->unmark_visited = db_unmark_visited;
	db_functions->get_mex = db_get_mex;
	db_functions->put_mex = db_put_mex;
	db_functions->get_winby = db_get_winby;
	db_functions->put_winby = db_put_winby;
	db_functions->save_database = db_save_database;
	db_functions->load_database = db_load_database;
	db_functions->free_db = db_free;
	db_functions->get_bulk = db_get_bulk;
}

/**
 * Finalize PC Groups: free DBMaps and config.
 * @public
 */
void do_final_pc_groups(void)
{
	if (pc_group_db != NULL)
		pc_group_db->destroy(pc_group_db, group_db_clear_sub);
	if (pc_groupname_db != NULL)
		db_destroy(pc_groupname_db);
}

void channel_close(struct channel_data *cd)
{
	int j;
	char output[128];
	struct map_session_data *pl_sd;
	DBIterator* iter;

	if( cd == NULL || cd->type != CHN_USER )
		return;
	
	sprintf(output, msg_txt(804), cd->name);
	clif_channel_message(cd, output, -1);

	iter = db_iterator(cd->users_db);
	for( pl_sd = (struct map_session_data *)dbi_first(iter); dbi_exists(iter); pl_sd = (struct map_session_data *)dbi_next(iter) )
	{
		idb_remove(cd->users_db, pl_sd->bl.id);
		ARR_FIND(0, MAX_USER_CHANNELS, j, pl_sd->cd[j] == cd);
		if( j == MAX_USER_CHANNELS )
			continue;
		
		pl_sd->cd[j] = NULL;
	}
	dbi_destroy(iter);
	
	db_destroy(cd->users_db);
	strdb_remove(channel_db, cd->name);
}

void do_final(void)
{
	if( gm_account_db )
	{
		db_destroy(gm_account_db);
		gm_account_db = NULL;
	}
}

/**
 * Program dispatch; get a line of input, and call the appropriate
 * command function.
 */
int main( int argc, char** argv ) {
#if DEBUG
	printf( "Program executed with %d arguments: \n", argc-1 );
	for ( int i = 1; i < argc; i++ ) {
		printf( "Argument: %s \n", argv[i] );
	}
	printf( "\n" );
#endif

	// Check for -v argument
	char* verbose_arg = "-v";
	for ( int i = 1; i < argc; i++ ) {
		if ( strcmp( verbose_arg, argv[i] ) == 0 ) {
			verbose = 1;
		}
	}

	// Initialize database and setup error function
	db_database* db = db_init();
	database = db;
	atexit( cleanup_db );

	// Main loop, get input and process it line by line
	char input[ LINE_SIZE ];   // input buffer
	char* tokens[ ARGS_SIZE ]; // array of pointers into input buffer
	int count;                 // count of input tokens
	char* command;             // the command string
	while ( ( count = tokenize_input( input, tokens ) ) >= 0 ) {

		// Dispatch processing based on the inputted command
		command = tokens[0];

		if ( strcmp( "student", command ) == 0 ) {
			db_new_student( db, tokens[1], tokens + 2 );

		} else if ( strcmp( "open", command ) == 0 ) {
			db_new_course( db, tokens[1], atoi( tokens[2] ) );

		} else if ( strcmp( "cancel", command ) == 0 ) {
			db_cancel_course( db, tokens[1] );

		} else if ( strcmp( "enroll", command ) == 0 ) {
			db_enroll_student( db, tokens[1], tokens[2] );

		} else if ( strcmp( "withdraw", command ) == 0 ) {
			db_withdraw_student( db, tokens[1], tokens[2] );

		}
	}

	// Done processing input
	db_dump( db );
	db_destroy( db );
	database = NULL;

	return 0;
}

void db_run_destruction(MYSQL_RES *dstrres)
{
	char delquery[QUERYLEN];
	MYSQL_ROW data;
	unsigned long uid;
	char *estr;

	if (!dstrres)
	{
		return;
	}
	if (mysql_num_rows(dstrres) < 1)
	{
		mysql_free_result(dstrres);
		return;
	}

	if (!ldb_init())
	{
		if (LocalDB)
		{
			if (rundaemon) { syslog(LOG_WARNING, "LocalDB connection failed: %s", mysql_error(LocalDB)); }
			else if (dlvl(1)) { fprintf(stdout, "LocalDB connection failed: %s\n", mysql_error(LocalDB)); }
			ldb_deinit();
		}
		else
		{
			if (rundaemon) { syslog(LOG_WARNING, "LocalDB connection failed: unknown"); }
			else if (dlvl(1)) { fprintf(stdout, "LocalDB connection failed: unknown\n"); }
		}
		mysql_free_result(dstrres);
		return;
	}
	while (data = mysql_fetch_row(dstrres))
	{
		uid = stringtoulong(data[1]);
		if (db_destroy(data[0], data[2]) == 0)
		{
			estr = (char *)malloc((strlen(data[0]) * 2) + 1);
			memset(estr, 0, ((strlen(data[0]) * 2) + 1));
			mysql_real_escape_string(DBhandle, estr, data[0], strlen(data[0]));
			memset(delquery, 0, QUERYLEN);
			snprintf(delquery, QUERYLEN, "delete from sql_destroy where uid=%lu and name=\"%s\"", uid, estr);
			free(estr);
			if (dlvl(5) && !rundaemon) { fprintf(stdout, "QUERY: %s\n", delquery); }
			mysql_query(DBhandle, delquery);
		}
	}
	mysql_free_result(dstrres);
	ldb_deinit();
}

int
main (int   argc,
      char *argv[])
{
   const bson_t *b;
   extent_t extent;
   record_t record;
   char *str;
   db_t db;
   ns_t ns;

   if (argc != 3) {
      fprintf(stderr, "usage: mdbdump DBPATH DBNAME\n");
      return ARGC_FAILURE;
   }

   errno = 0;
   if (!!db_init(&db, argv[1], argv[2])) {
      perror("Failed to load database");
      return DB_FAILURE;
   }

   errno = 0;
   if (!!db_namespaces(&db, &ns)) {
      perror("Failed to load namespaces");
      return NS_FAILURE;
   }

   do {
      //fprintf(stdout, "\nNamespace \"%s\"\n\n", ns_name(&ns));
      if (!!ns_extents(&ns, &extent)) {
         perror("Failed to load extent");
         return EXTENT_FAILURE;
      }
      do {
         if (!extent_records(&extent, &record)) {
            do {
               b = record_bson(&record);
               if ((str = bson_as_json(b, NULL))) {
                  puts(str);
               }
               bson_free(str);
            } while (!record_next(&record));
         }
      } while (!extent_next(&extent));
   } while (ns_next(&ns));

   db_destroy(&db);

   return 0;
}

/**
 * Delete a channel
 * - Checks if there is any user in channel and make them quit
 * @param channel: Channel data
 * @param force: Forcefully remove channel
 * @return
 *   0: Success
 *  -1: Invalid channel
 *  -2: Can't delete now
 */
int channel_delete(struct Channel *channel, bool force) {
	if(!channel)
		return -1;
	if(!force && channel->type == CHAN_TYPE_PUBLIC && runflag == MAPSERVER_ST_RUNNING) //only delete those serv stop
		return -2;
	if( db_size(channel->users)) {
		struct map_session_data *sd;
		DBIterator *iter = db_iterator(channel->users);
		for( sd = (struct map_session_data *)dbi_first(iter); dbi_exists(iter); sd = (struct map_session_data *)dbi_next(iter) ) { //for all users
			channel_clean(channel,sd,1); //make all quit
		}
		dbi_destroy(iter);
	}
	if (battle_config.etc_log)
		ShowInfo("Deleting channel %s alias %s type %d\n",channel->name,channel->alias,channel->type);
	db_destroy(channel->users);
	db_destroy(channel->banned);
	if (channel->groups)
		aFree(channel->groups);
	channel->groups = NULL;
	channel->group_count = 0;
	switch(channel->type){
	case CHAN_TYPE_MAP:
		map_getmapdata(channel->m)->channel = NULL;
		aFree(channel);
		break;
	case CHAN_TYPE_ALLY: {
		struct guild *g = guild_search(channel->gid);
		if(g) g->channel = NULL;
		aFree(channel);
		break;
	}
	default:
		strdb_remove(channel_db, channel->name);
		break;
	}
	return 0;
}

void raconf_destroy(raconf rc){
	DBIterator *iter;
	struct conf_value *v;
	
	// Clear all entrys in db.
	iter = db_iterator(rc->db);
	for( v = (struct conf_value*)dbi_first(iter);  dbi_exists(iter);  v = (struct conf_value*)dbi_next(iter) ){
		aFree(v);
	}
	dbi_destroy(iter);

	db_destroy(rc->db);
	
	aFree(rc);	
	
}//end: raconf_destroy()

void HPM_HP_final(void) {
	int i, len = HPMHooks.data.total * 2;

	if( hp_db )
		db_destroy(hp_db);

	for(i = 0; i < len; i++) {
		int *count = (int *)((char *)&HPMHooks.count + (sizeof(int)*(i)));

		if( count && *count ) {
			struct HPMHookPoint **hp = (struct HPMHookPoint **)((char *)&HPMHooks.list + (sizeof(struct HPMHookPoint *)*(i)));

			if( hp && *hp )
				aFree(*hp);
		}
	}
}

/*--------------------------------------
 * Removes a instance, all its maps and npcs.
 *--------------------------------------*/
void instance_destroy(int instance_id)
{
	int last = 0, type;
	struct party_data *p;
	time_t now = time(NULL);

	if( !instance_is_valid(instance_id) )
		return; // nothing to do

	if( instance[instance_id].progress_timeout && instance[instance_id].progress_timeout <= now )
		type = 1;
	else if( instance[instance_id].idle_timeout && instance[instance_id].idle_timeout <= now )
		type = 2;
	else
		type = 3;

	clif_instance(instance_id, 5, type); // Report users this instance has been destroyed

	while( instance[instance_id].num_map && last != instance[instance_id].map[0] )
	{ // Remove all maps from instance
		last = instance[instance_id].map[0];
		instance_del_map( instance[instance_id].map[0] );
	}

	if( instance[instance_id].vars )
		db_destroy(instance[instance_id].vars);

	if( instance[instance_id].progress_timer != INVALID_TIMER )
		delete_timer( instance[instance_id].progress_timer, instance_destroy_timer);
	if( instance[instance_id].idle_timer != INVALID_TIMER )
		delete_timer( instance[instance_id].idle_timer, instance_destroy_timer);

	instance[instance_id].vars = NULL;

	if( instance[instance_id].party_id && (p = party_search(instance[instance_id].party_id)) != NULL )
		p->instance_id = 0; // Update Party information

	ShowInfo("[Instance] Destroyed %s.\n", instance[instance_id].name);
	memset( &instance[instance_id], 0x00, sizeof(instance[0]) );

	instance[instance_id].state = INSTANCE_FREE;
}

//.........这里部分代码省略.........
        if ( 0 != WSAStartup(0x0201, &WSAData) ) {
                ED2KD_LOGERR("WSAStartup failed!");
                return EXIT_FAILURE;
        }
#endif

        if ( !server_load_config(NULL) ) {
                ED2KD_LOGERR("failed to load configuration file");
                return EXIT_FAILURE;
        }

        display_libevent_info();

#ifdef EVTHREAD_USE_WINDOWS_THREADS_IMPLEMENTED
        ret = evthread_use_windows_threads();
#elif EVTHREAD_USE_PTHREADS_IMPLEMENTED
        ret = evthread_use_pthreads();
#else
#error "unable to determine threading model"
#endif
        if ( ret < 0 ) {
                ED2KD_LOGERR("failed to init libevent threading model");
                return EXIT_FAILURE;
        }

        g_srv.evbase_main = event_base_new();
        if ( NULL == g_srv.evbase_main ) {
                ED2KD_LOGERR("failed to create main event loop");
                return EXIT_FAILURE;
        }
        g_srv.evbase_tcp = event_base_new();
        if ( NULL == g_srv.evbase_tcp ) {
                ED2KD_LOGERR("failed to create tcp event loop");
                return EXIT_FAILURE;
        }

        evsig_int = evsignal_new(g_srv.evbase_main, SIGINT, sigint_cb, NULL);
        evsignal_add(evsig_int, NULL);

        // common timers timevals
        g_srv.portcheck_timeout_tv = event_base_init_common_timeout(g_srv.evbase_tcp, &g_srv.cfg->portcheck_timeout_tv);
        g_srv.status_notify_tv = event_base_init_common_timeout(g_srv.evbase_tcp, &g_srv.cfg->status_notify_tv);

        if ( !db_create() ) {
                ED2KD_LOGERR("failed to create database");
                return EXIT_FAILURE;
        }

        g_srv.thread_count = omp_get_num_procs() + 1;

        pthread_cond_init(&g_srv.job_cond, NULL);
        pthread_mutex_init(&g_srv.job_mutex, NULL);
        TAILQ_INIT(&g_srv.jqueue);

        job_threads = (pthread_t *)malloc(g_srv.thread_count * sizeof(*job_threads));

        // start tcp worker threads
        for ( i=0; i<g_srv.thread_count; ++i ) {
                pthread_create(&job_threads[i], NULL, server_job_worker, NULL);
        }

        // start tcp dispatch thread
        pthread_create(&tcp_thread, NULL, server_base_worker, g_srv.evbase_tcp);

        // start tcp listen loop
        if ( !server_listen() ) {
                ED2KD_LOGERR("failed to start server listener");
                server_stop();
        }

        pthread_join(tcp_thread, NULL);

        while ( EBUSY == pthread_cond_destroy(&g_srv.job_cond) ) {
                pthread_cond_broadcast(&g_srv.job_cond);
                //pthread_yield();
        }

        pthread_mutex_destroy(&g_srv.job_mutex);

        for ( i=0; i<g_srv.thread_count; ++i ) {
                pthread_join(job_threads[i], NULL);
        }

        free(job_threads);

        // todo: free job queue items

        evconnlistener_free(g_srv.tcp_listener);
        event_free(evsig_int);
        event_base_free(g_srv.evbase_tcp);
        event_base_free(g_srv.evbase_main);

        if ( db_destroy() < 0 ) {
                ED2KD_LOGERR("failed to destroy database");
        }

        server_free_config();

        return EXIT_SUCCESS;
}

//.........这里部分代码省略.........

    /* create cache root if needed */
    if (!is_dir(CACHE_ROOT))
    {
        if (mkdir(CACHE_ROOT, S_IRWXU) != 0)
            FATAL("failed to create cache directory %s\n", CACHE_ROOT);
    }


    /*---------------------*
     * initialize database *
     *---------------------*/

    /* set db filename */
    db_file = join_path(discofs_options.data_root, "db.sqlite");

    /* create database file if it doesn't exist  */
    int fd = open(db_file, (O_RDONLY | O_CREAT), (S_IRUSR | S_IWUSR));
    if (fd == -1)
    {
        perror(db_file);
        FATAL("couldn't open or create database file\n");
    }
    close(fd);

    /* initialize tables etc */
    db_init(db_file, discofs_options.clear);

    /* try to load filesystem features from DB */
    if (db_cfg_get_int(CFG_FS_FEATURES, &discofs_options.fs_features))
    {

        /* if loading failed, try to determine them */
        if (is_mounted(REMOTE_ROOT) && is_reachable(discofs_options.host))
        {
            if (test_fs_features(&discofs_options.fs_features))
            {
                ERROR("failed to test remote fs features\n");
                discofs_options.fs_features = 0;
            }
            /* test succeeded, store value for next time */
            else
                db_cfg_set_int(CFG_FS_FEATURES, discofs_options.fs_features);
        }
        /* nag and assume that no features available (but don't save that) */
        else
        {
            ERROR("could not determine remote fs features");
            discofs_options.fs_features = 0;
        }
    }


    /*------------------*
     * initialize stuff *
     *------------------*/
    #define INIT(name)                          \
        if (name ## _init())                    \
            FATAL("error initializing " #name)
    INIT(lock);
    INIT(sync);
    INIT(job);
    #undef INIT


    /*----------------------*
     * print options to log *
     *----------------------*/
    log_options(LOG_VERBOSE, discofs_options);


    /*-----------------*
     * run fuse_main() *
     *-----------------*/
    ret = fuse_main(args.argc, args.argv, &discofs_oper, NULL);


    /*------*
     * exit *
     *------*/

    lock_destroy();
    sync_destroy();
    job_destroy();

    /* free arguments */
    fuse_opt_free_args(&args);

    /* close database connection */
    db_destroy();


    /* end logging */
    INFO("exiting\n");
    log_destroy();


    /* return fuse_main()s return value */
    return ret;
}

void DestroyDatabases()
{
	db_destroy();
}

/**
 * Function to be executed before at exit, to cleanup the database if needed.
 */
void cleanup_db( void ) {
	if ( database != NULL ) {
		db_destroy( database );
	}
}