// handleMessage gets messages received on the IRC network and parses them to recognize commands.
func (a *Amigo) handleMessage(msg *irc.Message) {
	// Handle panics
	defer func() {
		if r := recover(); r != nil {
			log.Println("!!! I'm panicking !!! ", r)
		}
	}()

	// Log message
	log.Println(msg.String())

	// Handle PING
	if msg.Command == "PING" {
		a.Send("PONG :" + msg.Trailing)
	}

	// Handle message
	if msg.Command == "PRIVMSG" {
		// Are you talking to me?
		if strings.HasPrefix(msg.Trailing, a.Nick) {
			a.handleCommand(msg)
		} else {
			// Free talk ('say when', 'cmd when')
			a.handleConversation(msg)
		}
	}
}

// Write handles sending messages, it reconnects if there are problems
// can be called concurrently
func (c *IConn) Write(m *irc.Message) {
	if t := c.rateLimit(m.Len()); t != 0 {
		<-time.After(t)
	}

	c.w <- m
}

func (server *Server) NewMessage(msg *irc.Message, serverAddr string) (string, error) {
	message := &Message{
		Message: msg.String(),
		Server:  serverAddr,
	}

	serialized, err := json.Marshal(message)

	return string(serialized), err
}

func (net *netImpl) privmsg(evt *msg.Message) {
	if evt.Params[0][0] == '@' {
		evt.Params[0] = evt.Params[0][1:]
	}
	if evt.IsServer() {
		if evt.Params[0][0] != '#' {
			return
		}
		evt.Name = fmt.Sprintf("SERVER [%s]", evt.Name)
	}
	net.ReceiveMessage(evt.Params[0], evt.Name, "privmsg", evt.Trailing)
}

func MsgHandler(s ircx.Sender, m *irc.Message) {
	message := strings.Split(m.String(), " ")
	user := strings.Split(message[0], "!")[0][1:]

	err := db.Update(func(tx *bolt.Tx) error {
		words := make(map[string]uint64)
		message[3] = message[3][1:]

		for _, element := range message[3:] {
			words[element]++
		}

		b := tx.Bucket([]byte(*channel))
		bu := b.Bucket([]byte(users))
		bm := b.Bucket([]byte(messages))

		v := bu.Get([]byte(user))
		var count uint64 = 0
		if v != nil {
			count = ByteToUint64(v)
		}

		count = count + uint64(len(message[3:]))
		err := bu.Put([]byte(user), Uint64ToByte(count))
		if err != nil {
			return err
		}

		for word, count := range words {
			v := bm.Get([]byte(word))
			var sum uint64 = 0

			if v != nil {
				sum = ByteToUint64(v)
			}

			sum = sum + count
			err := bm.Put([]byte(word), Uint64ToByte(sum))
			if err != nil {
				return err
			}
		}

		return nil
	})

	if err != nil {
		log.Fatal(err)
	} else {
		log.Println(user + " said " + strings.Join(message[3:], " "))
	}
}

func PrivacyFilterIrcmsg(message *irc.Message) *irc.Message {
	if message == nil {
		return nil
	}
	if message.Command == irc.PRIVMSG || message.Command == irc.NOTICE {
		message.Trailing = "<privacy filtered>"
	}
	if message.Command == irc.PASS {
		message.Params = []string{"<privacy filtered>"}
		message.Trailing = ""
	}
	return message
}

func (logger *Logger) logRaw(msg *irc.Message, server string) {
	timestamp := time.Now().Format(time.RFC3339)
	entry := &rawLog{
		Server:    server,
		TimeStamp: timestamp,
		Message:   msg.String(),
	}

	_, err := rdb.DB("bot").Table("raw_logs").Insert(entry).RunWrite(logger.DbSession)

	if err != nil {
		fmt.Println(err)
		return
	}
}

// CmdPing is a handler for the /PING command.
func CmdPing(s Server, u *User, msg *irc.Message) error {
	if len(msg.Params) > 0 {
		msg.Trailing = msg.Params[0]
	}
	s.EncodeMessage(u, irc.PONG, []string{s.Name()}, msg.Trailing)
	return nil
}

// send converts |msg| into a RobustMessage and appends it to |reply|.
func (i *IRCServer) send(reply *Replyctx, msg *irc.Message) *types.RobustMessage {
	if reply.lastmsg == msg {
		return reply.Messages[len(reply.Messages)-1]
	}

	reply.replyid++

	robustmsg := &types.RobustMessage{
		// The IDs must be the same across servers.
		Id: types.RobustId{
			Id:    reply.msgid,
			Reply: reply.replyid,
		},
		Data:           string(msg.Bytes()),
		InterestingFor: make(map[int64]bool),
	}

	reply.Messages = append(reply.Messages, robustmsg)
	reply.lastmsg = msg

	return robustmsg
}

func MessageHandler(s ircx.Sender, m *irc.Message) {
	msg := m.Trailing
	var command string
	if m.Params[0] == name {
		m.Params = []string{m.Name}
	}

	if strings.HasPrefix(strings.ToLower(msg), strings.ToLower(name)) {
		pieces := strings.Split(msg, " ")
		if len(pieces) >= 2 {
			command = pieces[1]
			runCommand(command, pieces, msg, s, m)
			return
		}
	} else if strings.HasPrefix(msg, prefix) {
		pieces := strings.Split(msg, " ")
		if len(pieces) >= 1 {
			command = pieces[0][1:]
			runCommand(command, pieces, msg, s, m)
			return
		}
	} else if strings.HasPrefix(msg, "\x01VERSION") {
		log.Println(ctcp.VersionReply())
		s.Send(&irc.Message{
			Command:  irc.PRIVMSG,
			Params:   m.Params,
			Trailing: ctcp.VersionReply(),
		})
		return
	} else {
		for k := range replies {
			if ok := k.FindAllString(msg, 1); ok != nil {
				s.Send(&irc.Message{
					Command:  irc.PRIVMSG,
					Params:   m.Params,
					Trailing: replies[k],
				})
				return
			}
		}
	}
}

// CmdPrivMsg is a handler for the /PRIVMSG command.
func CmdPrivMsg(s Server, u *User, msg *irc.Message) error {
	var err error
	if len(msg.Params) > 1 {
		tr := strings.Join(msg.Params[1:], " ")
		msg.Trailing = msg.Trailing + tr
	}
	// empty message
	if msg.Trailing == "" {
		return nil
	}
	query := msg.Params[0]
	if ch, exists := s.HasChannel(query); exists {
		//p := strings.Replace(query, "#", "", -1)
		msg.Trailing = strings.Replace(msg.Trailing, "\r", "", -1)
		// fix non-rfc clients
		if !strings.HasPrefix(msg.Trailing, ":") {
			if len(msg.Params) == 2 {
				msg.Trailing = msg.Params[1]
			}
		}
		// CTCP ACTION (/me)
		if strings.HasPrefix(msg.Trailing, "\x01ACTION ") {
			msg.Trailing = strings.Replace(msg.Trailing, "\x01ACTION ", "", -1)
			msg.Trailing = "*" + msg.Trailing + "*"
		}
		msg.Trailing += " ​"
		post := &model.Post{ChannelId: ch.ID(), Message: msg.Trailing}
		_, err := u.mc.Client.CreatePost(post)
		if err != nil {
			u.MsgSpoofUser("mattermost", "msg: "+msg.Trailing+" could not be send: "+err.Error())
		}
	} else if toUser, exists := s.HasUser(query); exists {
		if query == "mattermost" {
			go u.handleMMServiceBot(toUser, msg.Trailing)
			return nil
		}
		if toUser.MmGhostUser {
			u.mc.SendDirectMessage(toUser.User, msg.Trailing)
			return nil
		}
		err = s.EncodeMessage(u, irc.PRIVMSG, []string{toUser.Nick}, msg.Trailing)
	} else {
		err = s.EncodeMessage(u, irc.ERR_NOSUCHNICK, msg.Params, "No such nick/channel")
	}
	return err
}

func (h *HandlerFuncs) HandlePirvMsg(m *irc.Message) (err error) {

	// Print Private messagess
	log.Printf("%s: %s %s %s\n", h.Name, m.Command, m.Prefix.Name, m.Trailing)

	// Check for portal reference
	if val, ok := responses.Portal[m.Trailing]; ok {

		err = h.ClientConn.PrivMsg(m.Params[0], val)
		if err != nil {

			log.Printf("ircutil.PrivMsg(): %s\n", err)
			return
		}

		return
	}

	// Check for DDG query
	if strings.HasPrefix(m.Trailing, "!ddg") {

		m.Trailing = strings.TrimPrefix(m.Trailing, "!ddg")
		if m.Trailing == "" {

			err = h.ClientConn.PrivMsg(m.Params[0], fmt.Sprintf("%s: %s", m.Prefix.Name, "No Query Specified"))
			if err != nil {

				log.Printf("ircutil.PrivMsg(): %s\n", err)
				return err
			}
			return
		}

		q := &ddg.Client{

			Dial:   h.Dial,
			NoHTML: true,
		}
		_, text, err := q.FeelingLucky(m.Trailing)
		if err != nil {

			log.Printf("ddg.FeelingLucky(): %s\n", err)
		}
		if len(text) < 1 {

			text = "No Results"
		}

		err = h.ClientConn.PrivMsg(m.Params[0], fmt.Sprintf("%s: %s", m.Prefix.Name, text))
		if err != nil {

			log.Printf("ircutil.PrivMsg(): %s\n", err)
			return err
		}
	}

	// Check if message contains URL
	if crawler.IsURL(m.Trailing) {

		if strings.HasPrefix(m.Trailing, "dontcrawl") {

			return
		}

		c := &crawler.Client{
			Dial: h.Dial,
		}
		r, err := c.Crawl(crawler.ExtractUrl(m.Trailing))
		if err != nil {

			log.Printf("crawler.GetTitle(): %s\n", err)
			return nil
		}
		if len(r.Title) > 1 {

			err = h.ClientConn.PrivMsg(m.Params[0], fmt.Sprintf("^ %s", r.Title))
			if err != nil {

				log.Printf("ircutil.PrivMsg(): %s\n", err)
				return err
			}
		}
	}

	return
}

func (net *netImpl) rawHandler(evt *msg.Message) {
	// libmauirc adds the trailing text as a param, remove it.
	evt.Params = evt.Params[:len(evt.Params)-1]
	net.Owner.SendMessage(messages.Container{Type: messages.MsgRaw, Object: messages.RawMessage{Network: net.GetName(), Message: evt.String()}})
}

func (server *Server) sendMessage(msg *irc.Message) error {
	if msg.Command != irc.PRIVMSG {
		fmt.Printf(">> %s\n", msg.String())
	}
	return server.Writer.Encode(msg)
}

func (channel *IrcChannel) handlePrivMsg(msg *irc.Message) {
	//fmt.Println(msg)
	fmt_msg := new(TwitchChat)
	fmt_msg.raw = msg.String()

	// Parse the tags out of the PRIVMSG for use in the front end

	// Parse usertype
	reUserType, err := regexp.Compile(`user-type\=(.*?)(\;|\s)`)
	if err != nil {
		log.Print("Could not parse UserType\n")
	}
	fmt_msg.usertype = reUserType.FindStringSubmatch(fmt_msg.raw)

	// Parse subscriber
	reSub, err := regexp.Compile(`subscriber\=(.*?)(\;|\s)`)
	if err != nil {
		log.Print("Could not parse Subscriber\n")
	}
	fmt_msg.sub = reSub.FindStringSubmatch(fmt_msg.raw)

	// Parse turbo
	reTurbo, err := regexp.Compile(`turbo\=(.*?)(\;|\s)`)
	if err != nil {
		log.Print("Could not parse Turbo\n")
	}
	fmt_msg.turbo = reTurbo.FindStringSubmatch(fmt_msg.raw)

	// Parse display name
	reDisp, err := regexp.Compile(`display-name\=(.*?)(\;|\s)`)
	if err != nil {
		log.Print("Could not parse DisplayName\n")
	}
	fmt_msg.disp_name = reDisp.FindStringSubmatch(fmt_msg.raw)

	// Parse color tag
	reColor, err := regexp.Compile(`#[[:xdigit:]]{6}`)
	if err != nil {
		log.Print("Could not parse Color\n")
	}
	fmt_msg.color = reColor.FindStringSubmatch(fmt_msg.raw)

	if len(fmt_msg.color) == 1 && len(fmt_msg.disp_name) >= 1 && len(fmt_msg.sub) >= 1 && len(fmt_msg.turbo) >= 1 && len(fmt_msg.usertype) >= 1 {
		// User has all fields (mod or staff)
		// <a href='https://www.twitch.tv/" + msg.Prefix.Name + "/profile' target='_blank'><strong>" + fmt_msg.disp_name[1] + "</strong></a>
		channel.ReadFromChannel <- []byte("<span data-usertype='" + fmt_msg.usertype[1] + "' data-sub='" + fmt_msg.sub[1] + "' data-turbo='" + fmt_msg.turbo[1] +
			"' style='color:" + fmt_msg.color[0] + "' id='username'><strong>" + fmt_msg.disp_name[1] + "</strong></span><span id='text'>: " + html.EscapeString(msg.Trailing) + " </span>")
	} else if len(fmt_msg.color) == 1 && len(fmt_msg.disp_name) >= 1 && len(fmt_msg.sub) >= 1 && len(fmt_msg.turbo) >= 1 {
		// User is missing user-type tag (non-mod)
		channel.ReadFromChannel <- []byte("<span data-sub='" + fmt_msg.sub[1] + "' data-turbo='" + fmt_msg.turbo[1] + "' style='color:" + fmt_msg.color[0] +
			"' id='username'><strong>" + fmt_msg.disp_name[1] + "</strong></span><span id='text'>: " + html.EscapeString(msg.Trailing) + " </span>")
	} else if len(fmt_msg.color) == 1 && len(fmt_msg.disp_name) >= 1 {
		// User is missing user-type, subscriber, and turbo tags (rare)
		channel.ReadFromChannel <- []byte("<span data-sub='0' data-turbo='0' style='color:" + fmt_msg.color[0] +
			"' id='username'><strong>" + fmt_msg.disp_name[1] + "</strong></span><span id='text'>: " + html.EscapeString(msg.Trailing) + " </span>")
	} else if len(fmt_msg.color) == 1 {
		// User is bot (or not authenticated)
		channel.ReadFromChannel <- []byte("<span style='color:" + fmt_msg.color[0] + "' id='username'><strong>" + msg.Prefix.Name + "</strong></span><span id='text'>: " + html.EscapeString(msg.Trailing) + " </span>")
	} else {
		// Randomize colors if the user has never set them before
		rand.Seed(time.Now().UTC().UnixNano())
		colors := []string{
			"#FF0000",
			"#0000FF",
			"#008000",
			"#B22222",
			"#FF7F50",
			"#9ACD32",
			"#FF4500",
			"#2E8B57",
			"#DAA520",
			"#D2691E",
			"#5F9EA0",
			"#1E90FF",
			"#FF69B4",
			"#8A2BE2",
			"#00FF7F",
		}

		/* Map colors to the name, broken for some reason
		color, ok := fmt_msg.colorMap[msg.Prefix.Name]
		if !ok {
			color = colors[rand.Intn(len(colors))]
			fmt_msg.colorMap[msg.Prefix.Name] = color
		}*/

		color := colors[rand.Intn(len(colors))]

		if len(fmt_msg.disp_name) >= 1 && len(fmt_msg.sub) >= 1 && len(fmt_msg.turbo) >= 1 && len(fmt_msg.usertype) >= 1 {
			// User has all fields (mod or staff)
			channel.ReadFromChannel <- []byte("<span data-usertype='" + fmt_msg.usertype[1] + "' data-sub='" + fmt_msg.sub[1] + "' data-turbo='" + fmt_msg.turbo[1] +
				"' style='color:" + color + "' id='username'><strong>" + fmt_msg.disp_name[1] + "</strong></span><span id='text'>: " + html.EscapeString(msg.Trailing) + " </span>")
		} else if len(fmt_msg.disp_name) >= 1 && len(fmt_msg.sub) >= 1 && len(fmt_msg.turbo) >= 1 {
			// User is missing user-type tag (non-mod)
			channel.ReadFromChannel <- []byte("<span data-sub='" + fmt_msg.sub[1] + "' data-turbo='" + fmt_msg.turbo[1] + "' style='color:" + color +
				"' id='username'><strong>" + fmt_msg.disp_name[1] + "</strong></span><span id='text'>: " + html.EscapeString(msg.Trailing) + " </span>")
		} else if len(fmt_msg.disp_name) >= 1 {
			// User is missing user-type, subscriber, and turbo tags (rare)
			channel.ReadFromChannel <- []byte("<span data-sub='0' data-turbo='0' style='color:" + color +
				"' id='username'><strong>" + fmt_msg.disp_name[1] + "</strong></span><span id='text'>: " + html.EscapeString(msg.Trailing) + " </span>")
//.........这里部分代码省略.........

func (sender ServerSender) Send(msg *irc.Message, server string) {
	fmt.Printf(">> %s\n", msg.String())

	sender.r.Publish(server, msg.String())
}

// SendStruct sends a message.
func (b *Bot) SendStruct(msg *irc.Message) {
	b.SendString(msg.String())
}