package matterclient

import (
	"crypto/tls"
	"encoding/json"
	"errors"
	"fmt"
	"net/http"
	"net/http/cookiejar"
	"net/url"
	"strconv"
	"strings"
	"sync"
	"time"

	log "github.com/Sirupsen/logrus"

	"github.com/gorilla/websocket"
	"github.com/jpillora/backoff"
	"github.com/mattermost/platform/model"
)

type Credentials struct {
	Login         string
	Team          string
	Pass          string
	Server        string
	NoTLS         bool
	SkipTLSVerify bool
}

type Message struct {
	Raw      *model.WebSocketEvent
	Post     *model.Post
	Team     string
	Channel  string
	Username string
	Text     string
	Type     string
	UserID   string
}

type Team struct {
	Team         *model.Team
	Id           string
	Channels     *model.ChannelList
	MoreChannels *model.ChannelList
	Users        map[string]*model.User
}

type MMClient struct {
	sync.RWMutex
	*Credentials
	Team          *Team
	OtherTeams    []*Team
	Client        *model.Client
	User          *model.User
	Users         map[string]*model.User
	MessageChan   chan *Message
	log           *log.Entry
	WsClient      *websocket.Conn
	WsQuit        bool
	WsAway        bool
	WsConnected   bool
	WsSequence    int64
	WsPingChan    chan *model.WebSocketResponse
	ServerVersion string
}

func New(login, pass, team, server string) *MMClient {
	cred := &Credentials{Login: login, Pass: pass, Team: team, Server: server}
	mmclient := &MMClient{Credentials: cred, MessageChan: make(chan *Message, 100), Users: make(map[string]*model.User)}
	mmclient.log = log.WithFields(log.Fields{"module": "matterclient"})
	log.SetFormatter(&log.TextFormatter{FullTimestamp: true})
	return mmclient
}

func (m *MMClient) SetLogLevel(level string) {
	l, err := log.ParseLevel(level)
	if err != nil {
		log.SetLevel(log.InfoLevel)
		return
	}
	log.SetLevel(l)
}

func (m *MMClient) Login() error {
	// check if this is a first connect or a reconnection
	firstConnection := true
	if m.WsConnected == true {
		firstConnection = false
	}
	m.WsConnected = false
	if m.WsQuit {
		return nil
	}
	b := &backoff.Backoff{
		Min:    time.Second,
		Max:    5 * time.Minute,
		Jitter: true,
	}
	uriScheme := "https://"
	if m.NoTLS {
		uriScheme = "http://"
	}
	// login to mattermost
	m.Client = model.NewClient(uriScheme + m.Credentials.Server)
	m.Client.HttpClient.Transport = &http.Transport{TLSClientConfig: &tls.Config{InsecureSkipVerify: m.SkipTLSVerify}, Proxy: http.ProxyFromEnvironment}
	m.Client.HttpClient.Timeout = time.Second * 10

	for {
		d := b.Duration()
		// bogus call to get the serverversion
		m.Client.GetClientProperties()
		if firstConnection && !supportedVersion(m.Client.ServerVersion) {
			return fmt.Errorf("unsupported mattermost version: %s", m.Client.ServerVersion)
		}
		m.ServerVersion = m.Client.ServerVersion
		if m.ServerVersion == "" {
			m.log.Debugf("Server not up yet, reconnecting in %s", d)
			time.Sleep(d)
		} else {
			m.log.Infof("Found version %s", m.ServerVersion)
			break
		}
	}
	b.Reset()

	var myinfo *model.Result
	var appErr *model.AppError
	var logmsg = "trying login"
	for {
		m.log.Debugf("%s %s %s %s", logmsg, m.Credentials.Team, m.Credentials.Login, m.Credentials.Server)
		if strings.Contains(m.Credentials.Pass, model.SESSION_COOKIE_TOKEN) {
			m.log.Debugf(logmsg+" with %s", model.SESSION_COOKIE_TOKEN)
			token := strings.Split(m.Credentials.Pass, model.SESSION_COOKIE_TOKEN+"=")
			if len(token) != 2 {
				return errors.New("incorrect MMAUTHTOKEN. valid input is MMAUTHTOKEN=yourtoken")
			}
			m.Client.HttpClient.Jar = m.createCookieJar(token[1])
			m.Client.MockSession(token[1])
			myinfo, appErr = m.Client.GetMe("")
			if appErr != nil {
				return errors.New(appErr.DetailedError)
			}
			if myinfo.Data.(*model.User) == nil {
				m.log.Errorf("LOGIN TOKEN: %s is invalid", m.Credentials.Pass)
				return errors.New("invalid " + model.SESSION_COOKIE_TOKEN)
			}
		} else {
			myinfo, appErr = m.Client.Login(m.Credentials.Login, m.Credentials.Pass)
		}
		if appErr != nil {
			d := b.Duration()
			m.log.Debug(appErr.DetailedError)
			if firstConnection {
				if appErr.Message == "" {
					return errors.New(appErr.DetailedError)
				}
				return errors.New(appErr.Message)
			}
			m.log.Debugf("LOGIN: %s, reconnecting in %s", appErr, d)
			time.Sleep(d)
			logmsg = "retrying login"
			continue
		}
		break
	}
	// reset timer
	b.Reset()

	err := m.initUser()
	if err != nil {
		return err
	}

	if m.Team == nil {
		return errors.New("team not found")
	}
	// set our team id as default route
	m.Client.SetTeamId(m.Team.Id)

	m.wsConnect()

	return nil
}

func (m *MMClient) wsConnect() {
	b := &backoff.Backoff{
		Min:    time.Second,
		Max:    5 * time.Minute,
		Jitter: true,
	}

	m.WsConnected = false
	wsScheme := "wss://"
	if m.NoTLS {
		wsScheme = "ws://"
	}

	// setup websocket connection
	wsurl := wsScheme + m.Credentials.Server + model.API_URL_SUFFIX_V3 + "/users/websocket"
	header := http.Header{}
	header.Set(model.HEADER_AUTH, "BEARER "+m.Client.AuthToken)

	m.log.Debugf("WsClient: making connection: %s", wsurl)
	for {
		wsDialer := &websocket.Dialer{Proxy: http.ProxyFromEnvironment, TLSClientConfig: &tls.Config{InsecureSkipVerify: m.SkipTLSVerify}}
		var err error
		m.WsClient, _, err = wsDialer.Dial(wsurl, header)
		if err != nil {
			d := b.Duration()
			m.log.Debugf("WSS: %s, reconnecting in %s", err, d)
			time.Sleep(d)
			continue
		}
		break
	}

	m.log.Debug("WsClient: connected")
	m.WsSequence = 1
	m.WsPingChan = make(chan *model.WebSocketResponse)
	// only start to parse WS messages when login is completely done
	m.WsConnected = true
}

func (m *MMClient) Logout() error {
	m.log.Debugf("logout as %s (team: %s) on %s", m.Credentials.Login, m.Credentials.Team, m.Credentials.Server)
	m.WsQuit = true
	m.WsClient.Close()
	m.WsClient.UnderlyingConn().Close()
	if strings.Contains(m.Credentials.Pass, model.SESSION_COOKIE_TOKEN) {
		m.log.Debug("Not invalidating session in logout, credential is a token")
		return nil
	}
	_, err := m.Client.Logout()
	if err != nil {
		return err
	}
	return nil
}

func (m *MMClient) WsReceiver() {
	for {
		var rawMsg json.RawMessage
		var err error

		if m.WsQuit {
			m.log.Debug("exiting WsReceiver")
			return
		}

		if !m.WsConnected {
			time.Sleep(time.Millisecond * 100)
			continue
		}

		if _, rawMsg, err = m.WsClient.ReadMessage(); err != nil {
			m.log.Error("error:", err)
			// reconnect
			m.wsConnect()
		}

		var event model.WebSocketEvent
		if err := json.Unmarshal(rawMsg, &event); err == nil && event.IsValid() {
			m.log.Debugf("WsReceiver event: %#v", event)
			msg := &Message{Raw: &event, Team: m.Credentials.Team}
			m.parseMessage(msg)
			m.MessageChan <- msg
			continue
		}

		var response model.WebSocketResponse
		if err := json.Unmarshal(rawMsg, &response); err == nil && response.IsValid() {
			m.log.Debugf("WsReceiver response: %#v", response)
			m.parseResponse(response)
			continue
		}
	}
}

func (m *MMClient) parseMessage(rmsg *Message) {
	switch rmsg.Raw.Event {
	case model.WEBSOCKET_EVENT_POSTED, model.WEBSOCKET_EVENT_POST_EDITED:
		m.parseActionPost(rmsg)
		/*
			case model.ACTION_USER_REMOVED:
				m.handleWsActionUserRemoved(&rmsg)
			case model.ACTION_USER_ADDED:
				m.handleWsActionUserAdded(&rmsg)
		*/
	}
}

func (m *MMClient) parseResponse(rmsg model.WebSocketResponse) {
	if rmsg.Data != nil {
		// ping reply
		if rmsg.Data["text"].(string) == "pong" {
			m.WsPingChan <- &rmsg
		}
	}
}

func (m *MMClient) parseActionPost(rmsg *Message) {
	data := model.PostFromJson(strings.NewReader(rmsg.Raw.Data["post"].(string)))
	// we don't have the user, refresh the userlist
	if m.GetUser(data.UserId) == nil {
		m.log.Infof("User %s is not known, ignoring message %s", data)
		return
	}
	rmsg.Username = m.GetUserName(data.UserId)
	rmsg.Channel = m.GetChannelName(data.ChannelId)
	rmsg.UserID = data.UserId
	rmsg.Type = data.Type
	teamid, _ := rmsg.Raw.Data["team_id"].(string)
	// edit messsages have no team_id for some reason
	if teamid == "" {
		// we can find the team_id from the channelid
		teamid = m.GetChannelTeamId(data.ChannelId)
		rmsg.Raw.Data["team_id"] = teamid
	}
	if teamid != "" {
		rmsg.Team = m.GetTeamName(teamid)
	}
	// direct message
	if rmsg.Raw.Data["channel_type"] == "D" {
		rmsg.Channel = m.GetUser(data.UserId).Username
	}
	rmsg.Text = data.Message
	rmsg.Post = data
	return
}

func (m *MMClient) UpdateUsers() error {
	mmusers, err := m.Client.GetProfiles(0, 50000, "")
	if err != nil {
		return errors.New(err.DetailedError)
	}
	m.Lock()
	m.Users = mmusers.Data.(map[string]*model.User)
	m.Unlock()
	return nil
}

func (m *MMClient) UpdateChannels() error {
	mmchannels, err := m.Client.GetChannels("")
	if err != nil {
		return errors.New(err.DetailedError)
	}
	var mmchannels2 *model.Result
	if m.mmVersion() >= 3.08 {
		mmchannels2, err = m.Client.GetMoreChannelsPage(0, 5000)
	} else {
		mmchannels2, err = m.Client.GetMoreChannels("")
	}
	if err != nil {
		return errors.New(err.DetailedError)
	}
	m.Lock()
	m.Team.Channels = mmchannels.Data.(*model.ChannelList)
	m.Team.MoreChannels = mmchannels2.Data.(*model.ChannelList)
	m.Unlock()
	return nil
}

func (m *MMClient) GetChannelName(channelId string) string {
	m.RLock()
	defer m.RUnlock()
	for _, t := range m.OtherTeams {
		if t == nil {
			continue
		}
		if t.Channels != nil {
			for _, channel := range *t.Channels {
				if channel.Id == channelId {
					return channel.Name
				}
			}
		}
		if t.MoreChannels != nil {
			for _, channel := range *t.MoreChannels {
				if channel.Id == channelId {
					return channel.Name
				}
			}
		}
	}
	return ""
}

func (m *MMClient) GetChannelId(name string, teamId string) string {
	m.RLock()
	defer m.RUnlock()
	if teamId == "" {
		teamId = m.Team.Id
	}
	for _, t := range m.OtherTeams {
		if t.Id == teamId {
			for _, channel := range append(*t.Channels, *t.MoreChannels...) {
				if channel.Name == name {
					return channel.Id
				}
			}
		}
	}
	return ""
}

func (m *MMClient) GetChannelTeamId(id string) string {
	m.RLock()
	defer m.RUnlock()
	for _, t := range append(m.OtherTeams, m.Team) {
		for _, channel := range append(*t.Channels, *t.MoreChannels...) {
			if channel.Id == id {
				return channel.TeamId
			}
		}
	}
	return ""
}

func (m *MMClient) GetChannelHeader(channelId string) string {
	m.RLock()
	defer m.RUnlock()
	for _, t := range m.OtherTeams {
		for _, channel := range append(*t.Channels, *t.MoreChannels...) {
			if channel.Id == channelId {
				return channel.Header
			}

		}
	}
	return ""
}

func (m *MMClient) PostMessage(channelId string, text string) {
	post := &model.Post{ChannelId: channelId, Message: text}
	m.Client.CreatePost(post)
}

func (m *MMClient) JoinChannel(channelId string) error {
	m.RLock()
	defer m.RUnlock()
	for _, c := range *m.Team.Channels {
		if c.Id == channelId {
			m.log.Debug("Not joining ", channelId, " already joined.")
			return nil
		}
	}
	m.log.Debug("Joining ", channelId)
	_, err := m.Client.JoinChannel(channelId)
	if err != nil {
		return errors.New("failed to join")
	}
	return nil
}

func (m *MMClient) GetPostsSince(channelId string, time int64) *model.PostList {
	res, err := m.Client.GetPostsSince(channelId, time)
	if err != nil {
		return nil
	}
	return res.Data.(*model.PostList)
}

func (m *MMClient) SearchPosts(query string) *model.PostList {
	res, err := m.Client.SearchPosts(query, false)
	if err != nil {
		return nil
	}
	return res.Data.(*model.PostList)
}

func (m *MMClient) GetPosts(channelId string, limit int) *model.PostList {
	res, err := m.Client.GetPosts(channelId, 0, limit, "")
	if err != nil {
		return nil
	}
	return res.Data.(*model.PostList)
}

func (m *MMClient) GetPublicLink(filename string) string {
	res, err := m.Client.GetPublicLink(filename)
	if err != nil {
		return ""
	}
	return res
}

func (m *MMClient) GetPublicLinks(filenames []string) []string {
	var output []string
	for _, f := range filenames {
		res, err := m.Client.GetPublicLink(f)
		if err != nil {
			continue
		}
		output = append(output, res)
	}
	return output
}

func (m *MMClient) UpdateChannelHeader(channelId string, header string) {
	data := make(map[string]string)
	data["channel_id"] = channelId
	data["channel_header"] = header
	m.log.Debugf("updating channelheader %#v, %#v", channelId, header)
	_, err := m.Client.UpdateChannelHeader(data)
	if err != nil {
		log.Error(err)
	}
}

func (m *MMClient) UpdateLastViewed(channelId string) {
	m.log.Debugf("posting lastview %#v", channelId)
	if m.mmVersion() >= 3.08 {
		view := model.ChannelView{ChannelId: channelId}
		res, _ := m.Client.ViewChannel(view)
		if res == false {
			m.log.Errorf("ChannelView update for %s failed", channelId)
		}
		return
	}
	_, err := m.Client.UpdateLastViewedAt(channelId, true)
	if err != nil {
		m.log.Error(err)
	}
}

func (m *MMClient) UsernamesInChannel(channelId string) []string {
	res, err := m.Client.GetProfilesInChannel(channelId, 0, 50000, "")
	if err != nil {
		m.log.Errorf("UsernamesInChannel(%s) failed: %s", channelId, err)
		return []string{}
	}
	members := res.Data.(map[string]*model.User)
	result := []string{}
	for _, member := range members {
		result = append(result, member.Nickname)
	}
	return result
}

func (m *MMClient) createCookieJar(token string) *cookiejar.Jar {
	var cookies []*http.Cookie
	jar, _ := cookiejar.New(nil)
	firstCookie := &http.Cookie{
		Name:   "MMAUTHTOKEN",
		Value:  token,
		Path:   "/",
		Domain: m.Credentials.Server,
	}
	cookies = append(cookies, firstCookie)
	cookieURL, _ := url.Parse("https://" + m.Credentials.Server)
	jar.SetCookies(cookieURL, cookies)
	return jar
}

// SendDirectMessage sends a direct message to specified user
func (m *MMClient) SendDirectMessage(toUserId string, msg string) {
	m.log.Debugf("SendDirectMessage to %s, msg %s", toUserId, msg)
	// create DM channel (only happens on first message)
	_, err := m.Client.CreateDirectChannel(toUserId)
	if err != nil {
		m.log.Debugf("SendDirectMessage to %#v failed: %s", toUserId, err)
		return
	}
	channelName := model.GetDMNameFromIds(toUserId, m.User.Id)

	// update our channels
	mmchannels, err := m.Client.GetChannels("")
	if err != nil {
		m.log.Debug("SendDirectMessage: Couldn't update channels")
		return
	}
	m.Lock()
	m.Team.Channels = mmchannels.Data.(*model.ChannelList)
	m.Unlock()

	// build & send the message
	msg = strings.Replace(msg, "\r", "", -1)
	post := &model.Post{ChannelId: m.GetChannelId(channelName, ""), Message: msg}
	m.Client.CreatePost(post)
}

// GetTeamName returns the name of the specified teamId
func (m *MMClient) GetTeamName(teamId string) string {
	m.RLock()
	defer m.RUnlock()
	for _, t := range m.OtherTeams {
		if t.Id == teamId {
			return t.Team.Name
		}
	}
	return ""
}

// GetChannels returns all channels we're members off
func (m *MMClient) GetChannels() []*model.Channel {
	m.RLock()
	defer m.RUnlock()
	var channels []*model.Channel
	// our primary team channels first
	channels = append(channels, *m.Team.Channels...)
	for _, t := range m.OtherTeams {
		if t.Id != m.Team.Id {
			channels = append(channels, *t.Channels...)
		}
	}
	return channels
}

// GetMoreChannels returns existing channels where we're not a member off.
func (m *MMClient) GetMoreChannels() []*model.Channel {
	m.RLock()
	defer m.RUnlock()
	var channels []*model.Channel
	for _, t := range m.OtherTeams {
		channels = append(channels, *t.MoreChannels...)
	}
	return channels
}

// GetTeamFromChannel returns teamId belonging to channel (DM channels have no teamId).
func (m *MMClient) GetTeamFromChannel(channelId string) string {
	m.RLock()
	defer m.RUnlock()
	var channels []*model.Channel
	for _, t := range m.OtherTeams {
		channels = append(channels, *t.Channels...)
		if t.MoreChannels != nil {
			channels = append(channels, *t.MoreChannels...)
		}
		for _, c := range channels {
			if c.Id == channelId {
				return t.Id
			}
		}
	}
	return ""
}

func (m *MMClient) GetLastViewedAt(channelId string) int64 {
	m.RLock()
	defer m.RUnlock()
	res, err := m.Client.GetChannel(channelId, "")
	if err != nil {
		return model.GetMillis()
	}
	data := res.Data.(*model.ChannelData)
	return data.Member.LastViewedAt
}

func (m *MMClient) GetUsers() map[string]*model.User {
	users := make(map[string]*model.User)
	m.RLock()
	defer m.RUnlock()
	for k, v := range m.Users {
		users[k] = v
	}
	return users
}

func (m *MMClient) GetUser(userId string) *model.User {
	m.Lock()
	defer m.Unlock()
	u, ok := m.Users[userId]
	if !ok {
		res, err := m.Client.GetProfilesByIds([]string{userId})
		if err != nil {
			return nil
		}
		u = res.Data.(map[string]*model.User)[userId]
		m.Users[userId] = u
	}
	return m.Users[userId]
}

func (m *MMClient) GetUserName(userId string) string {
	user := m.GetUser(userId)
	if user != nil {
		return user.Username
	}
	return ""
}

func (m *MMClient) GetStatus(userId string) string {
	res, err := m.Client.GetStatuses()
	if err != nil {
		return ""
	}
	status := res.Data.(map[string]string)
	if status[userId] == model.STATUS_AWAY {
		return "away"
	}
	if status[userId] == model.STATUS_ONLINE {
		return "online"
	}
	return "offline"
}

func (m *MMClient) GetStatuses() map[string]string {
	var ok bool
	statuses := make(map[string]string)
	res, err := m.Client.GetStatuses()
	if err != nil {
		return statuses
	}
	if statuses, ok = res.Data.(map[string]string); ok {
		for userId, status := range statuses {
			statuses[userId] = "offline"
			if status == model.STATUS_AWAY {
				statuses[userId] = "away"
			}
			if status == model.STATUS_ONLINE {
				statuses[userId] = "online"
			}
		}
	}
	return statuses
}

func (m *MMClient) GetTeamId() string {
	return m.Team.Id
}

func (m *MMClient) StatusLoop() {
	for {
		if m.WsQuit {
			return
		}
		if m.WsConnected {
			m.log.Debug("WS PING")
			m.sendWSRequest("ping", nil)
			select {
			case <-m.WsPingChan:
				m.log.Debug("WS PONG received")
			case <-time.After(time.Second * 5):
				m.Logout()
				m.WsQuit = false
				m.Login()
				go m.WsReceiver()
			}
		}
		time.Sleep(time.Second * 60)
	}
}

// initialize user and teams
func (m *MMClient) initUser() error {
	m.Lock()
	defer m.Unlock()
	initLoad, err := m.Client.GetInitialLoad()
	if err != nil {
		return err
	}
	initData := initLoad.Data.(*model.InitialLoad)
	m.User = initData.User
	// we only load all team data on initial login.
	// all other updates are for channels from our (primary) team only.
	//m.log.Debug("initUser(): loading all team data")
	for _, v := range initData.Teams {
		m.Client.SetTeamId(v.Id)
		mmusers, err := m.Client.GetProfiles(0, 50000, "")
		if err != nil {
			return errors.New(err.DetailedError)
		}
		t := &Team{Team: v, Users: mmusers.Data.(map[string]*model.User), Id: v.Id}
		mmchannels, err := m.Client.GetChannels("")
		if err != nil {
			return errors.New(err.DetailedError)
		}
		t.Channels = mmchannels.Data.(*model.ChannelList)
		if m.mmVersion() >= 3.08 {
			mmchannels, err = m.Client.GetMoreChannelsPage(0, 5000)
		} else {
			mmchannels, err = m.Client.GetMoreChannels("")
		}
		if err != nil {
			return errors.New(err.DetailedError)
		}
		t.MoreChannels = mmchannels.Data.(*model.ChannelList)
		m.OtherTeams = append(m.OtherTeams, t)
		if v.Name == m.Credentials.Team {
			m.Team = t
			m.log.Debugf("initUser(): found our team %s (id: %s)", v.Name, v.Id)
		}
		// add all users
		for k, v := range t.Users {
			m.Users[k] = v
		}
	}
	return nil
}

func (m *MMClient) sendWSRequest(action string, data map[string]interface{}) error {
	req := &model.WebSocketRequest{}
	req.Seq = m.WsSequence
	req.Action = action
	req.Data = data
	m.WsSequence++
	m.log.Debugf("sendWsRequest %#v", req)
	m.WsClient.WriteJSON(req)
	return nil
}

func (m *MMClient) mmVersion() float64 {
	v, _ := strconv.ParseFloat(string(m.ServerVersion[0:2])+"0"+string(m.ServerVersion[2]), 64)
	if string(m.ServerVersion[4]) == "." {
		v, _ = strconv.ParseFloat(m.ServerVersion[0:4], 64)
	}
	return v
}

func supportedVersion(version string) bool {
	if strings.HasPrefix(version, "3.5.0") ||
		strings.HasPrefix(version, "3.6.0") ||
		strings.HasPrefix(version, "3.7.0") ||
		strings.HasPrefix(version, "3.8.0") ||
		strings.HasPrefix(version, "3.9.0") ||
		strings.HasPrefix(version, "3.10.0") {
		return true
	}
	return false
}