// Load a room from a sitef file.
func LoadRoom(dirname string, id string) (room *Room, err error) {

	path := SavePathFor(dirname, "room", id)

	records, err := sitef.ParseFilename(path)
	if err != nil {
		return nil, err
	}

	if len(records) < 1 {
		return nil, errors.New("No room found!")
	}

	record := records[0]
	monolog.Info("Loading Room record: %s %v", path, record)

	room = new(Room)
	room.Entity.LoadSitef(*record)
	/*
	   account.Name            = record.Get("name")
	   account.Hash            = record.Get("hash")
	   account.Algo            = record.Get("algo")
	   account.Email           = record.Get("email")
	   account.Points          = record.GetIntDefault("points", 0)
	   account.Privilege       = Privilege(record.GetIntDefault("privilege",
	                               int(PRIVILEGE_NORMAL)))

	   var nchars int
	   nchars                  = record.GetIntDefault("characters", 0)
	   _ = nchars
	*/
	monolog.Info("Loaded Room: %s %v", path, room)
	return room, nil
}

func (me *Client) SetupNegotiate(millis int, command byte, option byte, yes_event telnet.EventType, no_event telnet.EventType) (bool, telnet.Event) {
	me.telnet.TelnetSendNegotiate(command, option)
	tev, timeout, close := me.TryReadEvent(millis)

	if tev == nil || timeout || close {
		monolog.Info("Timeout or close in TryReadEvent")
		return false, nil
	}

	evtype := telnet.EventTypeOf(tev)

	if evtype == no_event {
		monolog.Info("Negative event no_event %v %v %v", tev, evtype, no_event)
		return false, tev
	}

	if evtype != yes_event {
		monolog.Info("Unexpected event yes_event %v %v %v", tev, evtype, yes_event)
		return false, tev
	}

	if tev == nil {
		return false, tev
	}

	return true, tev
}

func runSupervisor() (status int) {
	monolog.Setup("woe.log", true, false)
	defer monolog.Close()
	enableDisableLogs()
	monolog.Info("Starting WOE supervisor.")
	for server_restart {
		// wd  , _ := os.Getwd()
		exe := fmt.Sprintf("%s", os.Args[0])
		argp := fmt.Sprintf("-l=%s", *server_tcpip)
		argel := fmt.Sprintf("-el=%s", *enable_logs)
		argdl := fmt.Sprintf("-dl=%s", *disable_logs)
		cmd := exec.Command(exe, "-s=true", argp, argel, argdl)
		monolog.Info("Starting server %s at %s.", exe, *server_tcpip)
		cmd.Stderr = os.Stderr
		cmd.Stdout = os.Stdout
		monolog.Debug("Server command line: %s.", cmd.Args)
		err := cmd.Run()
		monolog.Info("Server at %s shut down.", *server_tcpip)
		if err != nil {
			monolog.Error("Server shut down with error %s!", err)
			server_restart = false
			return 1
		}
	}
	return 0
}

func (me *Being) Init(kind string, name string, privilege Privilege,
	kin Entitylike, gender Entitylike, job Entitylike) *Being {
	if me == nil {
		return me
	}
	me.Entity.InitKind(kind, name, privilege)

	realkin := EntitylikeToKin(kin)
	realgen := EntitylikeToGender(gender)
	realjob := EntitylikeToJob(job)

	monolog.Info("Init being: Kin: %v", realkin)
	monolog.Info("Init being: Gender: %v", realgen)
	monolog.Info("Init being: Job: %v", realjob)

	me.Kin = realkin
	me.Gender = realgen
	me.Job = realjob

	me.Talents.GrowFrom(BasicTalent)
	me.Talents.GrowFrom(me.Kin.Talents)
	me.Talents.GrowFrom(me.Gender.Talents)
	me.Talents.GrowFrom(me.Job.Talents)

	me.Level = 1
	me.RecalculateVitals()

	return me
}

func (me *Server) onConnect(conn net.Conn) (err error) {
	id, err := me.findFreeID()
	if err != nil {
		monolog.Info("Refusing connection for %s: too many clients. ", conn.RemoteAddr().String())
		conn.Close()
		return nil
	}
	monolog.Info("New client connected from %s, id %d. ", conn.RemoteAddr().String(), id)
	client := NewClient(me, id, conn)
	me.clients[id] = client
	return client.Serve()
}

func (me Record) GetStruct(prefix string, structure interface{}) {
	monolog.Info("GetStruct: structure %v, %v\n", structure,
		reflect.TypeOf(structure))

	st := reflect.TypeOf(structure).Elem()
	vt := reflect.Indirect(reflect.ValueOf(structure))
	monolog.Info("GetStruct: type %v value %v\n", st, vt)

	for i := 0; i < st.NumField(); i++ {
		field := st.Field(i)
		key := prefix + strings.ToLower(field.Name)
		value := reflect.Indirect(vt).Field(i)
		me.GetValue(key, value)
	}
}

func (me *Lexer) TryLexing() {
	go me.Start()

	for token := range me.Output {
		monolog.Info("Token %s", token)
	}
}

// Load an account from a sitef file.
func LoadAccount(dirname string, name string) (account *Account, err error) {

	path := SavePathFor(dirname, "account", name)

	records, err := sitef.ParseFilename(path)
	if err != nil {
		return nil, err
	}

	if len(records) < 1 {
		return nil, errors.New("No record found!")
	}

	record := records[0]
	monolog.Info("Loading Account record: %s %v", path, record)

	account = new(Account)
	account.Name = record.Get("name")
	account.Hash = record.Get("hash")
	account.Algo = record.Get("algo")
	account.Email = record.Get("email")
	account.Points = record.GetIntDefault("points", 0)
	account.Privilege = Privilege(record.GetIntDefault("privilege",
		int(PRIVILEGE_NORMAL)))

	nchars := record.GetIntDefault("characters", 0)
	account.characters = make([]*Character, 0, nchars)
	monolog.Info("Try to load %d characters:\n", nchars)
	for index := 0; index < nchars; index++ {

		chid := record.GetArrayIndex("characters", index)
		monolog.Info("Loading character: %d %s\n", index, chid)

		ch, err := account.LoadCharacter(dirname, chid)
		if err != nil {
			monolog.Error("Could not load character %s: %s", chid, err.Error())
			// return nil, err
		} else {
			account.characters = append(account.characters, ch)
		}
	}

	/* Todo: load characters here... */
	monolog.Info("Loaded Account: %s %v", path, account)
	return account, nil
}

func (me *Server) Close() {
	monolog.Info("Closing server, shutting down tickers.")

	for name, _ := range me.tickers {
		me.RemoveTicker(name)
	}

	monolog.Info("Closing server, shutting down clients.")
	for _, client := range me.clients {
		if client.IsAlive() {
			client.Close()
		}
	}

	me.handleDisconnectedClients()
	monolog.Info("Closed server.")
}

// Check for MSDP (two way MSSP) support (but don't implement it yet)
func (me *Client) SetupMSDP() telnet.Event {

	ok, tev := me.SetupNegotiate(1000, t.TELNET_WILL, t.TELNET_TELOPT_MSDP, t.TELNET_DO_EVENT, t.TELNET_DONT_EVENT)
	if !ok {
		return tev
	}
	monolog.Info("Client %d accepts MSDP", me.id)
	me.info.msdp = true
	return nil
}

// Negotiate COMPRESS2 support
func (me *Client) SetupCompress2() telnet.Event {
	ok, tev := me.SetupNegotiate(1000, t.TELNET_WILL, t.TELNET_TELOPT_COMPRESS2, t.TELNET_DO_EVENT, t.TELNET_DONT_EVENT)
	if !ok {
		return tev
	}

	me.telnet.TelnetBeginCompress2()
	monolog.Info("Client #{@id} started COMPRESS2 compression")
	me.info.compress2 = true
	return tev
}

// Load a world from a sitef file.
func LoadWorld(dirname string, name string) (world *World, err error) {

	path := SavePathFor(dirname, "world", name)

	records, err := sitef.ParseFilename(path)
	if err != nil {
		return nil, err
	}

	if len(records) < 1 {
		return nil, errors.New("No record found!")
	}

	record := records[0]
	monolog.Info("Loading World record: %s %v", path, record)

	world = NewWorld(record.Get("name"), record.Get("motd"), dirname)
	monolog.Info("Loaded World: %s %v", path, world)
	return world, nil
}

// Negotiate BINARY support, for sending UTF-8. This is largely a courtesy to the cliennt,
// since woe will send UTF-8 anyway.
func (me *Client) SetupBinary() telnet.Event {
	ok, tev := me.SetupNegotiate(1000, t.TELNET_WILL, t.TELNET_TELOPT_BINARY, t.TELNET_DO_EVENT, t.TELNET_DONT_EVENT)
	if !ok {
		me.info.binary = false
		return tev
	}

	monolog.Info("Client #{@id} accepts BINARY")
	me.info.binary = true
	return tev
}

// negotiate suppress go ahead
func (me *Client) SetupSupressGA() telnet.Event {
	ok, tev := me.SetupNegotiate(1000, t.TELNET_WILL, t.TELNET_TELOPT_SGA, t.TELNET_DO_EVENT, t.TELNET_DONT_EVENT)
	if !ok {
		me.info.binary = false
		return tev
	}

	monolog.Info("Client #{@id} will suppress GA")
	me.info.sga = true
	return tev

}

func (me *Server) handleDisconnectedClients() {
	for me.alive {
		time.Sleep(1)
		for id, client := range me.clients {
			if !client.IsAlive() {
				monolog.Info("Client %d has disconnected.", client.id)
				client.Close()
				delete(me.clients, id)
			}
		}
	}
}

func (me *Server) SetupWorld() (err error) {
	me.World, err = world.LoadWorld(me.DataPath(), "WOE")

	if err != nil {
		monolog.Error("Could not load world WOE: %s", err)
		return err
	}

	if me.World == nil {
		monolog.Info("Creating new default world...")
		me.World = world.NewWorld("WOE", DEFAULT_MOTD, me.DataPath())
		err := me.World.Save(me.DataPath())
		if err != nil {
			monolog.Error("Could not save world: %v", err)
			return err
		} else {
			monolog.Info("Saved default world.")
		}
	}
	return nil
}

// Load an item from a sitef file.
func LoadItem(dirname string, id string) (item *Item, err error) {

	path := SavePathFor(dirname, "item", id)

	records, err := sitef.ParseFilename(path)
	if err != nil {
		return nil, err
	}

	if len(records) < 1 {
		return nil, errors.New("No item found!")
	}

	record := records[0]
	monolog.Info("Loading Item record: %s %v", path, record)

	item = new(Item)
	item.Entity.LoadSitef(*record)
	item.Quality = record.GetIntDefault("quality", 0)
	item.Price = record.GetIntDefault("price", -1)
	item.Level = record.GetIntDefault("level", -1)
	item.Kind = ItemKind(record.Get("kind"))
	item.Damage = DamageKind(record.Get("damage"))
	item.Equip = EquipWhere(record.Get("equip"))
	item.Upgrade = record.Get("upgrade")
	item.Degrade = record.Get("degrade")
	item.Teaches = record.Get("teaches")
	item.Craft = record.Get("craft")

	ningredients := record.GetIntDefault("ingredients", 0)

	for i := 0; i < ningredients; i++ {
		ingr := record.GetArrayIndex("ingredients", i)
		item.Ingredients = append(item.Ingredients, ingr)
	}

	monolog.Info("Loaded Item: %s %v", path, item)
	return item, nil
}

// Deletes the character itself from disk
func (me *Character) Delete(dirname string) bool {
	path := SavePathFor(dirname, "character", me.ID)

	if err := os.Remove(path); err != nil {
		monolog.Warning("Could not delete character: %v %s: %s",
			me, path, err.Error())
		return false
	}

	me.Account = nil
	monolog.Info("Character deleted: %s", me.ID)
	return true
}

func runServer() (status int) {
	monolog.Setup("woe.log", true, false)
	defer monolog.Close()
	enableDisableLogs()
	monolog.Info("Starting WOE server...")
	monolog.Info("Server will run at %s.", *server_tcpip)
	woe, err := server.NewServer(*server_tcpip)
	if err != nil {
		monolog.Error("Could not initialize server!")
		monolog.Error(err.Error())
		panic(err)
	}
	monolog.Info("Server at %s init ok.", *server_tcpip)
	defer woe.Close()
	status, err = woe.Serve()
	if err != nil {
		monolog.Error("Error while running WOE server!")
		monolog.Error(err.Error())
		panic(err)
	}
	monolog.Info("Server shut down without error indication.", *server_tcpip)
	return status
}

func NewServer(address string) (server *Server, err error) {
	listener, err := net.Listen("tcp", address)
	if err != nil {
		return nil, err
	}

	monolog.Info("Server listening on %s.", address)

	clients := make(map[int]*Client)
	tickers := make(map[string]*Ticker)

	server = &Server{address, listener, clients, tickers, true, nil, STATUS_RESTART}
	err = server.SetupWorld()
	if err != nil {
		monolog.Error("Could not set up or load world!")
		return nil, err
	}

	monolog.Info("Server world set up.")
	server.AddDefaultTickers()
	monolog.Info("Tickers set up.")

	return server, err
}