package rpc

import (
	"context"
	"encoding/binary"
	"net/url"

	"github.com/iamxvbaba/td/tg"
	"go.uber.org/zap"

	"telesrv/internal/domain"
	"telesrv/internal/sfu"
)

const (
	maxConferenceChainBlockBytes = 64 * 1024
	maxConferenceChainBlocks     = 100

	conferenceChainBlockConstructor            = 0x639a3db6
	conferenceChainBlockServerConstructor      = 0x639a3db7
	conferenceBroadcastCommitConstructor       = 0xd1512ae7
	conferenceBroadcastCommitServerConstructor = 0xd1512ae8
	conferenceBroadcastRevealConstructor       = 0x83f4f9d8
	conferenceBroadcastRevealServerConstructor = 0x83f4f9d9
)

func (r *Router) onPhoneCreateConferenceCall(ctx context.Context, req *tg.PhoneCreateConferenceCallRequest) (tg.UpdatesClass, error) {
	if req == nil {
		return nil, inputRequestInvalidErr()
	}
	if r.deps.GroupCalls == nil {
		return nil, notImplementedErr()
	}
	userID, err := r.phoneRequireUser(ctx)
	if err != nil {
		return nil, err
	}
	now := int(r.clock.Now().Unix())
	call, err := r.deps.GroupCalls.CreateConference(ctx, userID, int64(req.RandomID), 0, now)
	if err != nil {
		return nil, groupCallErr(err)
	}
	out := r.groupCallUpdateContainer(ctx, userID, domain.Channel{},
		&tg.UpdateGroupCall{Call: tgGroupCall(call, userID, true, r.cfg.PublicBaseURL)}, []int64{userID})
	if !req.Join {
		return out, nil
	}
	params, ok := req.GetParams()
	if !ok {
		return nil, groupCallInvalidErr()
	}
	joinReq := &tg.PhoneJoinGroupCallRequest{
		Muted:        req.Muted,
		VideoStopped: req.VideoStopped,
		Call:         &tg.InputGroupCall{ID: call.ID, AccessHash: call.AccessHash},
		JoinAs:       &tg.InputPeerSelf{},
		Params:       params,
	}
	if pk, ok := req.GetPublicKey(); ok {
		joinReq.SetPublicKey(pk)
	}
	if block, ok := req.GetBlock(); ok {
		joinReq.SetBlock(block)
	}
	joinUpdates, err := r.onPhoneJoinGroupCall(ctx, joinReq)
	if err != nil {
		return nil, err
	}
	appendUpdates(out, joinUpdates)
	return out, nil
}

func (r *Router) onPhoneExportGroupCallInvite(ctx context.Context, req *tg.PhoneExportGroupCallInviteRequest) (*tg.PhoneExportedGroupCallInvite, error) {
	if req == nil {
		return nil, inputRequestInvalidErr()
	}
	scope, err := r.groupCallScopeFrom(ctx, req.Call)
	if err != nil {
		return nil, err
	}
	if !scope.call.Active() {
		return nil, groupCallInvalidErr()
	}
	if scope.call.Conference() {
		link := conferenceExportInviteLink(scope.call, r.cfg.PublicBaseURL)
		if link == "" {
			return nil, groupCallInvalidErr()
		}
		return &tg.PhoneExportedGroupCallInvite{Link: link}, nil
	}
	if scope.call.InviteLink != "" {
		return &tg.PhoneExportedGroupCallInvite{Link: scope.call.InviteLink}, nil
	}
	if scope.channel.Username == "" {
		return nil, publicChannelMissingErr()
	}
	return &tg.PhoneExportedGroupCallInvite{Link: r.publicLink(scope.channel.Username)}, nil
}

func conferenceExportInviteLink(call domain.GroupCall, publicBaseURL ...string) string {
	if link := conferenceCanonicalInviteLink(call.InviteSlug, publicBaseURL...); link != "" {
		return link
	}
	return call.InviteLink
}

func conferenceCanonicalInviteLink(slug string, publicBaseURL ...string) string {
	if slug == "" {
		return ""
	}
	baseURL := ""
	if len(publicBaseURL) > 0 {
		baseURL = publicBaseURL[0]
	}
	return publicLinkQueryWithBaseURL(baseURL, "call/"+slug, url.Values{"slug": []string{slug}})
}

func (r *Router) onPhoneInviteConferenceCallParticipant(ctx context.Context, req *tg.PhoneInviteConferenceCallParticipantRequest) (tg.UpdatesClass, error) {
	if req == nil {
		return nil, inputRequestInvalidErr()
	}
	if r.deps.GroupCalls == nil || r.deps.Messages == nil {
		return nil, notImplementedErr()
	}
	scope, err := r.groupCallScopeFrom(ctx, req.Call)
	if err != nil {
		return nil, err
	}
	if !scope.call.Conference() || !scope.call.Active() {
		return nil, groupCallInvalidErr()
	}
	target, found, err := r.userFromInput(ctx, scope.userID, req.UserID)
	if err != nil {
		return nil, internalErr()
	}
	if !found || target.ID == 0 || target.Bot || target.ID == scope.userID {
		return nil, userIDInvalidErr()
	}
	if p, found, err := r.deps.GroupCalls.Participant(ctx, scope.call.ID, target.ID); err != nil {
		return nil, internalErr()
	} else if found && !p.Left {
		return nil, tgerr400("USER_ALREADY_PARTICIPANT")
	}
	recipientBlocked, err := r.peerBlocksUser(ctx, scope.userID, target.ID)
	if err != nil {
		return nil, err
	}
	now := int(r.clock.Now().Unix())
	randomID := conferenceInviteRandomID(scope.call.ID, target.ID, now)
	res, err := r.deps.Messages.SendPrivateText(ctx, scope.userID, domain.SendPrivateTextRequest{
		SenderUserID:    scope.userID,
		RecipientUserID: target.ID,
		RandomID:        randomID,
		Media: &domain.MessageMedia{
			Kind: domain.MessageMediaKindService,
			ServiceAction: &domain.MessageServiceAction{
				Kind: domain.MessageServiceActionConferenceCall,
				ConferenceCall: &domain.MessageConferenceCallAction{
					CallID: scope.call.ID,
					Video:  req.Video,
					OtherParticipants: []domain.Peer{
						{Type: domain.PeerTypeUser, ID: scope.userID},
					},
				},
			},
		},
		Date:             now,
		OriginAuthKeyID:  rawAuthKeyIDForOrigin(ctx),
		OriginSessionID:  sessionIDFromCtx(ctx),
		RecipientBlocked: recipientBlocked,
	})
	if err != nil {
		return nil, messageSendErr(err)
	}
	// Message and invite index currently live in separate stores/transactions. Always
	// retry the idempotent invite write, including an exact message replay, so a crash
	// after SendPrivateText commit cannot leave an unrecoverable message-without-index.
	invite, err := r.deps.GroupCalls.CreateConferenceInvite(ctx, domain.GroupCallInvite{
		CallID:        scope.call.ID,
		InviterUserID: scope.userID,
		InviteeUserID: target.ID,
		MessageID:     res.RecipientMessage.ID,
		Status:        domain.GroupCallInvitePending,
		Video:         req.Video,
		CreatedAt:     now,
	})
	if err != nil {
		return nil, groupCallErr(err)
	}
	_ = invite
	if res.Duplicate {
		// The first transaction already created both private boxes and their durable
		// update events. Replaying UpdateNewMessage here would reconstruct the service
		// message from the intentionally minimal immutable receipt and push it to the
		// invitee a second time. Only reconcile the caller's random_id and original pts;
		// The invite write above is an idempotent saga repair only; no message/update
		// side effect is repeated.
		return tgPrivateSendResultUpdates(res, randomID, true, nil, nil), nil
	}
	users := r.tgUsersForIDs(ctx, scope.userID, []int64{scope.userID, target.ID})
	out := tgPrivateMessageUpdates(res.SenderEvent, res.SenderMessage, 0, false, users, nil)
	recipientUsers := r.tgUsersForIDs(ctx, target.ID, []int64{scope.userID, target.ID})
	r.pushUserMessage(ctx, target.ID, "conference invite",
		tgPrivateMessageUpdates(res.RecipientEvent, res.RecipientMessage, 0, false, recipientUsers, nil))
	return out, nil
}

func (r *Router) onPhoneDeclineConferenceCallInvite(ctx context.Context, msgID int) (tg.UpdatesClass, error) {
	if r.deps.GroupCalls == nil {
		return nil, notImplementedErr()
	}
	userID, err := r.phoneRequireUser(ctx)
	if err != nil {
		return nil, err
	}
	call, inv, found, err := r.deps.GroupCalls.GetByInviteMessage(ctx, userID, msgID)
	if err != nil {
		return nil, internalErr()
	}
	if !found || !call.Conference() {
		return nil, msgIDInvalidErr()
	}
	now := int(r.clock.Now().Unix())
	if _, _, err := r.deps.GroupCalls.SetConferenceInviteStatus(ctx, call.ID, userID, msgID, domain.GroupCallInviteDeclined, now); err != nil {
		return nil, internalErr()
	}
	r.pushConferenceGroupCallUpdate(ctx, call)
	return r.groupCallUpdateContainer(ctx, userID, domain.Channel{},
		&tg.UpdateGroupCall{Call: tgGroupCall(call, userID, userID == call.CreatorUserID, r.cfg.PublicBaseURL)}, []int64{inv.InviterUserID, inv.InviteeUserID}), nil
}

func (r *Router) onPhoneDeleteConferenceCallParticipants(ctx context.Context, req *tg.PhoneDeleteConferenceCallParticipantsRequest) (tg.UpdatesClass, error) {
	if req == nil {
		return nil, inputRequestInvalidErr()
	}
	if len(req.IDs) == 0 || len(req.IDs) > 100 {
		return nil, limitInvalidErr()
	}
	if len(req.Block) > maxConferenceChainBlockBytes {
		return nil, limitInvalidErr()
	}
	scope, err := r.groupCallScopeFrom(ctx, req.Call)
	if err != nil {
		return nil, err
	}
	if !scope.call.Conference() {
		return nil, groupCallInvalidErr()
	}
	if req.OnlyLeft == req.Kick {
		return nil, inputRequestInvalidErr()
	}
	now := int(r.clock.Now().Unix())
	if req.OnlyLeft && !scope.canManage() {
		self, found, err := r.deps.GroupCalls.Participant(ctx, scope.call.ID, scope.userID)
		if err != nil {
			return nil, internalErr()
		}
		if !found || self.Left {
			return nil, groupCallForbiddenErr()
		}
	}
	for _, targetID := range req.IDs {
		if targetID <= 0 {
			return nil, userIDInvalidErr()
		}
		if req.Kick && targetID != scope.userID && !scope.canManage() {
			return nil, groupCallForbiddenErr()
		}
	}
	result, err := r.deps.GroupCalls.RemoveConferenceParticipants(ctx, domain.RemoveConferenceCallParticipantsRequest{
		CallID:        scope.call.ID,
		AuthorUserID:  scope.userID,
		TargetUserIDs: req.IDs,
		OnlyLeft:      req.OnlyLeft,
		Kick:          req.Kick,
		Block:         req.Block,
		Now:           now,
	})
	if err != nil {
		return nil, groupCallErr(err)
	}
	if result.ChainBlockAppended {
		block := result.ChainBlock
		r.pushConferenceChainBlocks(ctx, result.Call, block.SubChainID, [][]byte{block.Block}, block.Offset+1)
	}
	if len(result.ParticipantsChanged) > 0 {
		r.pushConferenceGroupCallParticipantsUpdate(ctx, result.Call, result.ParticipantsChanged)
		r.pushConferenceGroupCallUpdate(ctx, result.Call)
	}
	for _, p := range result.ParticipantsChanged {
		if r.deps.SFU != nil {
			_ = r.deps.SFU.Leave(ctx, scope.call.ID, p.UserID, sfu.EndpointMain)
		}
	}
	out := r.groupCallUpdateContainer(ctx, scope.userID, domain.Channel{},
		&tg.UpdateGroupCallParticipants{
			Call:         &tg.InputGroupCall{ID: result.Call.ID, AccessHash: result.Call.AccessHash},
			Participants: tgGroupCallParticipants(result.ParticipantsChanged, scope.userID),
			Version:      result.Call.Version,
		}, req.IDs)
	if result.ChainBlockAppended {
		block := result.ChainBlock
		out.Updates = append(out.Updates, conferenceChainBlocksUpdate(result.Call, block.SubChainID, [][]byte{block.Block}, block.Offset+1))
	}
	return out, nil
}

func (r *Router) onPhoneSendConferenceCallBroadcast(ctx context.Context, req *tg.PhoneSendConferenceCallBroadcastRequest) (tg.UpdatesClass, error) {
	if req == nil {
		return nil, inputRequestInvalidErr()
	}
	if len(req.Block) == 0 || len(req.Block) > maxConferenceChainBlockBytes {
		return nil, limitInvalidErr()
	}
	scope, err := r.groupCallScopeFrom(ctx, req.Call)
	if err != nil {
		return nil, err
	}
	if !scope.call.Conference() {
		return nil, groupCallInvalidErr()
	}
	if err := r.requireActiveConferenceParticipant(ctx, scope.call.ID, scope.userID); err != nil {
		return nil, err
	}
	now := int(r.clock.Now().Unix())
	block, err := r.deps.GroupCalls.AppendChainBlock(ctx, domain.GroupCallChainBlock{
		CallID:       scope.call.ID,
		SubChainID:   1,
		Offset:       -1,
		AuthorUserID: scope.userID,
		Block:        req.Block,
		CreatedAt:    now,
	})
	if err != nil {
		return nil, groupCallErr(err)
	}
	nextOffset := block.Offset + 1
	r.pushConferenceChainBlocks(ctx, scope.call, block.SubChainID, [][]byte{block.Block}, nextOffset)
	return r.conferenceChainBlocksUpdates(ctx, scope.userID, scope.call, block.SubChainID, [][]byte{block.Block}, nextOffset), nil
}

func (r *Router) requireActiveConferenceParticipant(ctx context.Context, callID, userID int64) error {
	if r.deps.GroupCalls == nil {
		return notImplementedErr()
	}
	p, found, err := r.deps.GroupCalls.Participant(ctx, callID, userID)
	if err != nil {
		return internalErr()
	}
	if !found || p.Left {
		return groupCallJoinMissingErr()
	}
	return nil
}

func (r *Router) onPhoneGetGroupCallChainBlocks(ctx context.Context, req *tg.PhoneGetGroupCallChainBlocksRequest) (tg.UpdatesClass, error) {
	if req == nil {
		return nil, inputRequestInvalidErr()
	}
	if req.Offset < domain.GroupCallChainBlockLatestOffset {
		return nil, inputRequestInvalidErr()
	}
	limit := req.Limit
	if limit <= 0 || limit > maxConferenceChainBlocks {
		limit = maxConferenceChainBlocks
	}
	scope, err := r.groupCallScopeFrom(ctx, req.Call)
	if err != nil {
		return nil, err
	}
	if !scope.call.Conference() {
		return nil, groupCallInvalidErr()
	}
	page, err := r.deps.GroupCalls.ChainBlocks(ctx, scope.call.ID, req.SubChainID, req.Offset, limit)
	if err != nil {
		return nil, groupCallErr(err)
	}
	blocks := make([][]byte, 0, len(page.Blocks))
	for _, row := range page.Blocks {
		blocks = append(blocks, row.Block)
	}
	return r.conferenceChainBlocksUpdates(ctx, scope.userID, scope.call, req.SubChainID, blocks, page.NextOffset), nil
}

func (r *Router) pushConferenceChainBlocks(ctx context.Context, call domain.GroupCall, subChainID int, blocks [][]byte, nextOffset int) {
	recipients := r.conferenceCallRecipients(ctx, call.ID)
	for _, viewerID := range recipients {
		r.pushUserMessage(ctx, viewerID, "conference chain blocks",
			r.conferenceChainBlocksUpdates(ctx, viewerID, call, subChainID, blocks, nextOffset))
	}
}

func (r *Router) conferenceChainBlocksUpdates(ctx context.Context, viewerID int64, call domain.GroupCall, subChainID int, blocks [][]byte, nextOffset int) *tg.Updates {
	return &tg.Updates{
		Updates: []tg.UpdateClass{conferenceChainBlocksUpdate(call, subChainID, blocks, nextOffset)},
		Users:   r.tgUsersForIDs(ctx, viewerID, []int64{viewerID}),
		Date:    int(r.clock.Now().Unix()),
		Seq:     0,
	}
}

func conferenceChainBlocksUpdate(call domain.GroupCall, subChainID int, blocks [][]byte, nextOffset int) *tg.UpdateGroupCallChainBlocks {
	return &tg.UpdateGroupCallChainBlocks{
		Call:       &tg.InputGroupCall{ID: call.ID, AccessHash: call.AccessHash},
		SubChainID: subChainID,
		Blocks:     conferenceServerBlocks(subChainID, blocks),
		NextOffset: nextOffset,
	}
}

func conferenceServerBlocks(subChainID int, blocks [][]byte) [][]byte {
	out := make([][]byte, 0, len(blocks))
	for _, block := range blocks {
		out = append(out, conferenceServerBlock(subChainID, block))
	}
	return out
}

func conferenceServerBlock(subChainID int, block []byte) []byte {
	out := append([]byte(nil), block...)
	if len(out) < 4 {
		return out
	}
	constructor := binary.LittleEndian.Uint32(out[:4])
	switch subChainID {
	case 0:
		if constructor == conferenceChainBlockConstructor {
			binary.LittleEndian.PutUint32(out[:4], conferenceChainBlockServerConstructor)
		}
	case 1:
		switch constructor {
		case conferenceBroadcastCommitConstructor:
			binary.LittleEndian.PutUint32(out[:4], conferenceBroadcastCommitServerConstructor)
		case conferenceBroadcastRevealConstructor:
			binary.LittleEndian.PutUint32(out[:4], conferenceBroadcastRevealServerConstructor)
		}
	}
	return out
}

func appendUpdates(dst *tg.Updates, src tg.UpdatesClass) {
	if dst == nil || src == nil {
		return
	}
	switch v := src.(type) {
	case *tg.Updates:
		dst.Updates = append(dst.Updates, v.Updates...)
		dst.Users = append(dst.Users, v.Users...)
		dst.Chats = append(dst.Chats, v.Chats...)
	case *tg.UpdatesCombined:
		dst.Updates = append(dst.Updates, v.Updates...)
		dst.Users = append(dst.Users, v.Users...)
		dst.Chats = append(dst.Chats, v.Chats...)
	}
}

func conferenceInviteRandomID(callID, targetID int64, date int) int64 {
	id := int64(0x636f6e6663616c) // "confcal"
	id ^= callID << 11
	id ^= targetID << 3
	id ^= int64(date) << 29
	if id == 0 {
		return 0x636f6e66
	}
	return id
}

func authKeyIDFromCtx(ctx context.Context) [8]byte {
	if authKeyID, ok := RawAuthKeyIDFrom(ctx); ok {
		return authKeyID
	}
	return [8]byte{}
}

func sessionIDFromCtx(ctx context.Context) int64 {
	if sessionID, ok := SessionIDFrom(ctx); ok {
		return sessionID
	}
	return 0
}

func (r *Router) logConferenceMessageFailure(callID int64, err error) {
	if err != nil {
		r.log.Warn("conference message", zap.Int64("call_id", callID), zap.Error(err))
	}
}