package util

import (
	"encoding/json"
	"fmt"
	"time"

	"huron.connectingnow.net/fholland/gorm_models/models"
)

func ExtractWithoutAttributes(base models.AnalyticsConversationWithoutAttributes) (models.DBConversation, []models.DBParticipant, []models.DBSession, []models.DBSegment) {

	var startTime *time.Time

	parsedStartTime, err := time.Parse(time.RFC3339, base.ConversationStart)
	if err != nil {
		startTime = nil
	} else {
		startTime = &parsedStartTime
	}

	var endTime *time.Time
	parsedEndTime, err := time.Parse(time.RFC3339, base.ConversationEnd)
	if err != nil {
		endTime = nil
	} else {
		endTime = &parsedEndTime
	}

	divisionIdsBytes, err := json.Marshal(base.DivisionIds)
	if err != nil {
		divisionIdsBytes = nil
	}
	divisionIdsBytesStr := string(divisionIdsBytes)

	conversation := models.DBConversation{
		DivisionIds:          &divisionIdsBytesStr,
		End:                  endTime,
		Id:                   base.ConversationId,
		MinMos:               &base.MediaStatsMinConversationMos,
		MinRFactor:           &base.MediaStatsMinConversationRFactor,
		OriginatingDirection: &base.OriginatingDirection,
		Start:                startTime,
	}
	var participants []models.DBParticipant
	var sessions []models.DBSession
	var segments []models.DBSegment

	for _, p := range base.Participants {

		participant := models.DBParticipant{
			// ConnectedTime:     nil,
			ConversationId: base.ConversationId,
			// EndTime:           nil,
			ExternalContactId: &p.ExternalContactId,
			Id:                p.ParticipantId,
			Name:              &p.ParticipantName,
			Purpose:           &p.Purpose,
			UserId:            &p.UserId,
		}
		participants = append(participants, participant)

		for _, sess := range p.Sessions {
			mediaEndpointStatsBytes, err := json.Marshal(sess.MediaEndpointStats)
			if err != nil {
				mediaEndpointStatsBytes = nil
			}

			metricsBytes, err := json.Marshal(sess.Metrics)
			if err != nil {
				metricsBytes = nil
			}

			flowBytes, err := json.Marshal(sess.Flow)
			if err != nil {
				flowBytes = nil
			}

			session := models.DBSession{
				Ani:                   sess.ANI,
				Direction:             sess.Direction,
				Dnis:                  sess.DNIS,
				EdgeId:                sess.EdgeId,
				Id:                    fmt.Sprintf("%s_%s", p.ParticipantId, sess.SessionId),
				MediaEndpointStats:    string(mediaEndpointStatsBytes),
				MediaType:             sess.MediaType,
				Metrics:               string(metricsBytes),
				ParticipantId:         p.ParticipantId,
				ProtocolCallId:        sess.ProtocolCallId,
				Provider:              sess.Provider,
				Recording:             sess.Recording,
				RemoteNameDisplayable: sess.RemoteNameDisplayable,
				SessionDnis:           sess.SessionDNIS,
				Flow:                  string(flowBytes),
			}
			sessions = append(sessions, session)

			for idx, seg := range sess.Segments {

				segmentStart, err := time.Parse(time.RFC3339, seg.SegmentStart)
				if err != nil {
					segmentStart = time.Now()
				}

				segmentEnd, err := time.Parse(time.RFC3339, seg.SegmentEnd)
				if err != nil {
					segmentEnd = time.Now()
				}

				q850ResponseCodesBytes, err := json.Marshal(seg.Q850ResponseCodes)
				if err != nil {
					q850ResponseCodesBytes = nil
				}

				segment := models.DBSegment{
					Id:                fmt.Sprintf("%s_%s_%d", session.Id, seg.SegmentType, idx),
					Conference:        seg.Conference,
					DisconnectType:    seg.DisconnectType,
					Q850ResponseCodes: string(q850ResponseCodesBytes),
					SegmentEnd:        segmentEnd,
					SegmentStart:      segmentStart,
					SegmentType:       seg.SegmentType,
					SessionId:         session.Id,
					WrapUpCode:        seg.WrapUpCode,
				}

				segments = append(segments, segment)
			}
		}
	}

	return conversation, participants, sessions, segments
}

func ExtractLive(base models.NotificationConversationWithAttributes) (models.DBConversation, []models.DBParticipant, []models.DBCall) {

	conversation := models.DBConversation{
		Id:                 base.Id,
		Address:            &base.Address,
		ExternalTag:        &base.ExternalTag,
		RecordingState:     &base.RecordingState,
		SecurePause:        &base.SecurePause,
		UtilizationLabelId: &base.UtilizationLabelId,
	}

	var participants []models.DBParticipant
	var calls []models.DBCall

	for _, partPayload := range base.Participants {
		attributesBytes, err := json.Marshal(partPayload.Attributes)
		if err != nil {
			attributesBytes = nil
		}
		attributesBytesStr := string(attributesBytes)

		mediaRolesBytes, err := json.Marshal(partPayload.MediaRoles)
		if err != nil {
			mediaRolesBytes = nil
		}
		mediaRolesBytesStr := string(mediaRolesBytes)

		wrapupBytes, err := json.Marshal(partPayload.Wrapup)
		if err != nil {
			wrapupBytes = nil
		}
		wrapupBytesStr := string(wrapupBytes)

		var connectedTime *time.Time
		parsedConnectedTime, err := time.Parse(time.RFC3339, partPayload.ConnectedTime)
		if err != nil {
			connectedTime = nil
		} else {
			connectedTime = &parsedConnectedTime
		}

		var endTime *time.Time
		parsedEndTime, err := time.Parse(time.RFC3339, partPayload.EndTime)
		if err != nil {
			endTime = nil
		} else {
			endTime = &parsedEndTime
		}

		participant := models.DBParticipant{
			ConversationId:                   base.Id,
			Id:                               partPayload.Id,
			Address:                          &partPayload.Address,
			Attributes:                       &attributesBytesStr,
			ConnectedTime:                    connectedTime,
			EndTime:                          endTime,
			ExternalContactId:                &partPayload.ExternalContactId,
			ExternalContactInitialDivisionId: &partPayload.ExternalContactInitialDivisionId,
			MediaRoles:                       &mediaRolesBytesStr,
			Name:                             &partPayload.Name,
			Purpose:                          &partPayload.Purpose,
			QueueId:                          &partPayload.QueueId,
			Wrapup:                           &wrapupBytesStr,
			WrapupExpected:                   &partPayload.WrapupExpected,
			WrapupRequired:                   &partPayload.WrapupRequired,
		}
		participants = append(participants, participant)

		for _, callPayload := range partPayload.Calls {
			var connectedTime *time.Time
			parsedConnectedTime, err := time.Parse(time.RFC3339, callPayload.ConnectedTime)
			if err != nil {
				connectedTime = nil
			} else {
				connectedTime = &parsedConnectedTime
			}

			var disconnectedTime *time.Time
			parsedDisconnectedTime, err := time.Parse(time.RFC3339, callPayload.DisconnectedTime)
			if err != nil {
				disconnectedTime = nil
			} else {
				disconnectedTime = &parsedDisconnectedTime
			}

			otherBytes, err := json.Marshal(callPayload.Other)
			if err != nil {
				otherBytes = nil
			}

			selfBytes, err := json.Marshal(callPayload.Self)
			if err != nil {
				selfBytes = nil
			}

			disconnectReasonsBytes, err := json.Marshal(callPayload.DisconnectReasons)
			if err != nil {
				disconnectReasonsBytes = nil
			}

			call := models.DBCall{
				ParticipantId:         partPayload.Id,
				AfterCallWorkRequired: callPayload.AfterCallWorkRequired,
				Confined:              callPayload.Confined,
				ConnectedTime:         connectedTime,
				DisconnectedTime:      disconnectedTime,
				Direction:             callPayload.Direction,
				DisconnectReasons:     string(disconnectReasonsBytes),
				DisconnectType:        callPayload.DisconnectType,
				Held:                  callPayload.Held,
				Id:                    callPayload.Id,
				InitialState:          callPayload.InitialState,
				Muted:                 callPayload.Muted,
				Other:                 string(otherBytes),
				Provider:              callPayload.Provider,
				Recording:             callPayload.Recording,
				RecordingState:        callPayload.RecordingState,
				SecurePause:           callPayload.SecurePause,
				Self:                  string(selfBytes),
				State:                 callPayload.State,
			}

			calls = append(calls, call)
		}
	}

	return conversation, participants, calls

}

//func ExtractWithAttributes(base models.AnalyticsConversationWithAttributes) (models.DBConversation, []models.DBParticipant, []models.DBSession, []models.DBSegment) {
//
//	var startTime *time.Time
//	parsedStartTime, err := time.Parse(time.RFC3339, base.ConversationStart)
//	if err != nil {
//		startTime = nil
//	} else {
//		startTime = &parsedStartTime
//	}
//
//	var endTime *time.Time
//	parsedEndTime, err := time.Parse(time.RFC3339, base.ConversationEnd)
//	if err != nil {
//		endTime = nil
//	} else {
//		endTime = &parsedEndTime
//	}
//
//	divisionIdsBytes, err := json.Marshal(base.DivisionIds)
//	if err != nil {
//		divisionIdsBytes = nil
//	}
//	divisionIdsBytesStr := string(divisionIdsBytes)
//
//	conversation := models.DBConversation{
//		DivisionIds:          &divisionIdsBytesStr,
//		End:                  endTime,
//		Id:                   base.ConversationId,
//		MinMos:               &base.MediaStatsMinConversationMos,
//		MinRFactor:           &base.MediaStatsMinConversationRFactor,
//		OriginatingDirection: &base.OriginatingDirection,
//		Start:                startTime,
//	}
//	var participants []models.DBParticipant
//	var sessions []models.DBSession
//	var segments []models.DBSegment
//
//	for _, p := range base.Participants {
//
//		attributesBytes, err := json.Marshal(p.Attributes)
//		if err != nil {
//			attributesBytes = nil
//		}
//		attributesBytesStr := string(attributesBytes)
//
//		participant := models.DBParticipant{
//			ConnectedTime:     nil,
//			ConversationId:    base.ConversationId,
//			EndTime:           nil,
//			ExternalContactId: &p.ExternalContactId,
//			Id:                p.ParticipantId,
//			Name:              &p.ParticipantName,
//			Purpose:           &p.Purpose,
//			Attributes:        &attributesBytesStr,
//		}
//		participants = append(participants, participant)
//
//		for _, sess := range p.Sessions {
//			mediaEndpointStatsBytes, err := json.Marshal(sess.MediaEndpointStats)
//			if err != nil {
//				mediaEndpointStatsBytes = nil
//			}
//
//			metricsBytes, err := json.Marshal(sess.Metrics)
//			if err != nil {
//				metricsBytes = nil
//			}
//
//			session := models.DBSession{
//				Ani:                   sess.ANI,
//				Direction:             sess.Direction,
//				Dnis:                  sess.DNIS,
//				EdgeId:                sess.EdgeId,
//				Id:                    fmt.Sprintf("%s_%s", p.ParticipantId, sess.SessionId),
//				MediaEndpointStats:    string(mediaEndpointStatsBytes),
//				MediaType:             sess.MediaType,
//				Metrics:               string(metricsBytes),
//				ParticipantId:         p.ParticipantId,
//				ProtocolCallId:        sess.ProtocolCallId,
//				Provider:              sess.Provider,
//				Recording:             sess.Recording,
//				RemoteNameDisplayable: sess.RemoteNameDisplayable,
//				SessionDnis:           sess.SessionDnis,
//			}
//			sessions = append(sessions, session)
//
//			for _, seg := range sess.Segments {
//
//				segmentStart, err := time.Parse(time.RFC3339, seg.SegmentStart)
//				if err != nil {
//					segmentStart = time.Now()
//				}
//
//				segmentEnd, err := time.Parse(time.RFC3339, seg.SegmentEnd)
//				if err != nil {
//					segmentEnd = time.Now()
//				}
//
//				q850ResponseCodesBytes, err := json.Marshal(seg.Q850ResponseCodes)
//				if err != nil {
//					q850ResponseCodesBytes = nil
//				}
//
//				segment := models.DBSegment{
//					Id:                fmt.Sprintf("%s_%s", session.Id, seg.SegmentType),
//					Conference:        seg.Conference,
//					DisconnectType:    seg.DisconnectType,
//					Q850ResponseCodes: string(q850ResponseCodesBytes),
//					SegmentEnd:        segmentEnd,
//					SegmentStart:      segmentStart,
//					SegmentType:       seg.SegmentType,
//					SessionId:         sess.SessionId,
//					WrapUpCode:        seg.WrapUpCode,
//				}
//
//				segments = append(segments, segment)
//			}
//		}
//	}
//
//	return conversation, participants, sessions, segments
//}