package models

import (
	"crypto/sha512"
	"encoding/hex"
	"fmt"
	"gogs.mikescher.com/BlackForestBytes/goext/dataext"
	"gogs.mikescher.com/BlackForestBytes/goext/langext"
	"gogs.mikescher.com/BlackForestBytes/goext/mathext"
	"gogs.mikescher.com/BlackForestBytes/goext/sq"
	"strconv"
	"strings"
	"time"
)

type MessageFilter struct {
	ConfirmedSubscriptionBy *UserID
	SearchString            *[]string
	Sender                  *[]UserID
	Owner                   *[]UserID
	ChannelNameCS           *[]string // case-sensitive
	ChannelNameCI           *[]string // case-insensitive
	ChannelID               *[]ChannelID
	SenderNameCS            *[]string // case-sensitive
	SenderNameCI            *[]string // case-insensitive
	SenderIP                *[]string
	TimestampCoalesce       *time.Time
	TimestampCoalesceAfter  *time.Time
	TimestampCoalesceBefore *time.Time
	TimestampReal           *time.Time
	TimestampRealAfter      *time.Time
	TimestampRealBefore     *time.Time
	TimestampClient         *time.Time
	TimestampClientAfter    *time.Time
	TimestampClientBefore   *time.Time
	TitleCS                 *string // case-sensitive
	TitleCI                 *string // case-insensitive
	Priority                *[]int
	UserMessageID           *[]string
	OnlyDeleted             bool
	IncludeDeleted          bool
}

func (f MessageFilter) SQL() (string, string, sq.PP, error) {

	joinClause := ""
	if f.ConfirmedSubscriptionBy != nil {
		joinClause += " LEFT JOIN subscriptions AS subs on messages.channel_id = subs.channel_id "
	}
	if f.SearchString != nil {
		joinClause += " JOIN messages_fts AS mfts on (mfts.rowid = messages.scn_message_id) "
	}

	sqlClauses := make([]string, 0)

	params := sq.PP{}

	if f.OnlyDeleted {
		sqlClauses = append(sqlClauses, "(deleted=1)")
	} else if f.IncludeDeleted {
		// nothing, return all
	} else {
		sqlClauses = append(sqlClauses, "(deleted=0)") // default
	}

	if f.ConfirmedSubscriptionBy != nil {
		sqlClauses = append(sqlClauses, "(subs.subscriber_user_id = :sub_uid AND subs.confirmed = 1)")
		params["sub_uid"] = *f.ConfirmedSubscriptionBy
	}

	if f.Sender != nil {
		filter := make([]string, 0)
		for i, v := range *f.Sender {
			filter = append(filter, fmt.Sprintf("(sender_user_id = :sender_%d)", i))
			params[fmt.Sprintf("sender_%d", i)] = v
		}
		sqlClauses = append(sqlClauses, "("+strings.Join(filter, " OR ")+")")
	}

	if f.Owner != nil {
		filter := make([]string, 0)
		for i, v := range *f.Sender {
			filter = append(filter, fmt.Sprintf("(owner_user_id = :owner_%d)", i))
			params[fmt.Sprintf("owner_%d", i)] = v
		}
		sqlClauses = append(sqlClauses, "("+strings.Join(filter, " OR ")+")")
	}

	if f.ChannelNameCI != nil {
		filter := make([]string, 0)
		for i, v := range *f.ChannelNameCI {
			filter = append(filter, fmt.Sprintf("(channel_name = :channelnameci_%d COLLATE NOCASE)", i))
			params[fmt.Sprintf("channelnameci_%d", i)] = v
		}
		sqlClauses = append(sqlClauses, "("+strings.Join(filter, " OR ")+")")
	}

	if f.ChannelNameCS != nil {
		filter := make([]string, 0)
		for i, v := range *f.ChannelNameCS {
			filter = append(filter, fmt.Sprintf("(channel_name = :channelnamecs_%d COLLATE BINARY)", i))
			params[fmt.Sprintf("channelnamecs_%d", i)] = v
		}
		sqlClauses = append(sqlClauses, "("+strings.Join(filter, " OR ")+")")
	}

	if f.ChannelID != nil {
		filter := make([]string, 0)
		for i, v := range *f.ChannelID {
			filter = append(filter, fmt.Sprintf("(channel_id = :channelid_%d)", i))
			params[fmt.Sprintf("channelid_%d", i)] = v
		}
		sqlClauses = append(sqlClauses, "("+strings.Join(filter, " OR ")+")")
	}

	if f.SenderNameCI != nil {
		filter := make([]string, 0)
		for i, v := range *f.ChannelNameCI {
			filter = append(filter, fmt.Sprintf("(sender_name = :sendernameci_%d COLLATE NOCASE)", i))
			params[fmt.Sprintf("sendernameci_%d", i)] = v
		}
		sqlClauses = append(sqlClauses, "(sender_name IS NOT NULL AND ("+strings.Join(filter, " OR ")+"))")
	}

	if f.SenderNameCS != nil {
		filter := make([]string, 0)
		for i, v := range *f.ChannelNameCS {
			filter = append(filter, fmt.Sprintf("(sender_name = :sendernamecs_%d COLLATE BINARY)", i))
			params[fmt.Sprintf("sendernamecs_%d", i)] = v
		}
		sqlClauses = append(sqlClauses, "(sender_name IS NOT NULL AND ("+strings.Join(filter, " OR ")+"))")
	}

	if f.SenderIP != nil {
		filter := make([]string, 0)
		for i, v := range *f.SenderIP {
			filter = append(filter, fmt.Sprintf("(sender_ip = :senderip_%d)", i))
			params[fmt.Sprintf("senderip_%d", i)] = v
		}
		sqlClauses = append(sqlClauses, "("+strings.Join(filter, " OR ")+")")
	}

	if f.TimestampCoalesce != nil {
		sqlClauses = append(sqlClauses, "(COALESCE(timestamp_client, timestamp_real) = :ts_equals)")
		params["ts_equals"] = (*f.TimestampCoalesce).UnixMilli()
	}

	if f.TimestampCoalesceAfter != nil {
		sqlClauses = append(sqlClauses, "(COALESCE(timestamp_client, timestamp_real) > :ts_after)")
		params["ts_after"] = (*f.TimestampCoalesceAfter).UnixMilli()
	}

	if f.TimestampCoalesceBefore != nil {
		sqlClauses = append(sqlClauses, "(COALESCE(timestamp_client, timestamp_real) < :ts_before)")
		params["ts_before"] = (*f.TimestampCoalesceBefore).UnixMilli()
	}

	if f.TimestampReal != nil {
		sqlClauses = append(sqlClauses, "(timestamp_real = :ts_real_equals)")
		params["ts_real_equals"] = (*f.TimestampRealAfter).UnixMilli()
	}

	if f.TimestampRealAfter != nil {
		sqlClauses = append(sqlClauses, "(timestamp_real > :ts_real_after)")
		params["ts_real_after"] = (*f.TimestampRealAfter).UnixMilli()
	}

	if f.TimestampRealBefore != nil {
		sqlClauses = append(sqlClauses, "(timestamp_real < :ts_real_before)")
		params["ts_real_before"] = (*f.TimestampRealAfter).UnixMilli()
	}

	if f.TimestampClient != nil {
		sqlClauses = append(sqlClauses, "(timestamp_client IS NOT NULL AND timestamp_client = :ts_client_equals)")
		params["ts_client_equals"] = (*f.TimestampClient).UnixMilli()
	}

	if f.TimestampClientAfter != nil {
		sqlClauses = append(sqlClauses, "(timestamp_client IS NOT NULL AND timestamp_client > :ts_client_after)")
		params["ts_client_after"] = (*f.TimestampClientAfter).UnixMilli()
	}

	if f.TimestampClientBefore != nil {
		sqlClauses = append(sqlClauses, "(timestamp_client IS NOT NULL AND timestamp_client < :ts_client_before)")
		params["ts_client_before"] = (*f.TimestampClientBefore).UnixMilli()
	}

	if f.TitleCI != nil {
		sqlClauses = append(sqlClauses, "(title = :titleci COLLATE NOCASE)")
		params["titleci"] = *f.TitleCI
	}

	if f.TitleCS != nil {
		sqlClauses = append(sqlClauses, "(title = :titleci COLLATE BINARY)")
		params["titleci"] = *f.TitleCI
	}

	if f.Priority != nil {
		prioList := "(" + strings.Join(langext.ArrMap(*f.Priority, func(p int) string { return strconv.Itoa(p) }), ", ") + ")"
		sqlClauses = append(sqlClauses, "(priority IN "+prioList+")")
	}

	if f.UserMessageID != nil {
		filter := make([]string, 0)
		for i, v := range *f.UserMessageID {
			filter = append(filter, fmt.Sprintf("(usr_message_id = :usermessageid_%d)", i))
			params[fmt.Sprintf("usermessageid_%d", i)] = v
		}
		sqlClauses = append(sqlClauses, "(usr_message_id IS NOT NULL AND ("+strings.Join(filter, " OR ")+"))")
	}

	if f.SearchString != nil {
		filter := make([]string, 0)
		for i, v := range *f.SearchString {
			filter = append(filter, fmt.Sprintf("(messages_fts match :searchstring_%d)", i))
			params[fmt.Sprintf("searchstring_%d", i)] = v
		}
		sqlClauses = append(sqlClauses, "("+strings.Join(filter, " OR ")+")")
	}

	sqlClause := ""
	if len(sqlClauses) > 0 {
		sqlClause = strings.Join(sqlClauses, " AND ")
	} else {
		sqlClause = "1=1"
	}

	return sqlClause, joinClause, params, nil
}

func (f MessageFilter) Hash() string {
	bh, err := dataext.StructHash(f, dataext.StructHashOptions{HashAlgo: sha512.New()})
	if err != nil {
		return "00000000"
	}

	str := hex.EncodeToString(bh)
	return str[0:mathext.Min(8, len(bh))]
}