package mapper

import (
	"edge-infra.dev/pkg/edge/api/bsl/types"
	"edge-infra.dev/pkg/edge/api/graph/model"
	"edge-infra.dev/pkg/edge/api/utils"
	"edge-infra.dev/pkg/edge/bsl"
)

const (
	// DefaultLatitude default coordinate latitude value for BSL Site p.s. import cycle import from services
	DefaultLatitude = 90.0
	// DefaultLongitude default coordinate longitude value for BSL Site p.s. import cycle import from services
	DefaultLongitude = 180.0
)

func ToStoreSiteInfo(site *bsl.BSLInfo) *model.StoreSiteInfo {
	dayparts := make([]*model.Dayparts, 0)
	customAttributeSets := make([]*model.CustomAttributeSets, 0)
	enterpriseSettings := make([]*model.EnterpriseSettings, 0)
	hours := make([]*model.Hours, 0)
	contacts := make([]*model.Contacts, 0)
	for _, daypart := range site.DayParts {
		daypartRef := daypart
		dayparts = append(dayparts, &model.Dayparts{
			Name:        &daypartRef.Name,
			Day:         &daypartRef.Day,
			Description: &daypartRef.Description,
			StartTime:   &daypartRef.StartTime,
			EndTime:     &daypartRef.EndTime,
		})
	}
	for _, customAttributeSet := range site.CustomAttributeSets {
		customAttributeSetRef := customAttributeSet
		attributes := make([]*model.Attributes, 0)
		for _, attribute := range customAttributeSetRef.Attributes {
			attribute := attribute
			attributes = append(attributes, &model.Attributes{
				Key:   &attribute.Key,
				Value: &attribute.Value,
			})
		}
		customAttributeSets = append(customAttributeSets, &model.CustomAttributeSets{
			TypeName:   &customAttributeSetRef.TypeName,
			Attributes: attributes,
		})
	}
	if len(site.EnterpriseSettings) > 0 {
		configurationSettings := make([]*model.ConfigurationSettings, 0)
		for _, enterpriseSetting := range site.EnterpriseSettings {
			enterpriseSettingRef := enterpriseSetting
			if len(enterpriseSettingRef.ConfigurationSettings) > 0 {
				for _, configurationSetting := range enterpriseSettingRef.ConfigurationSettings {
					configurationSetting := configurationSetting
					configurationSettings = append(configurationSettings, &model.ConfigurationSettings{
						Key:   &configurationSetting.Key,
						Value: &configurationSetting.Value,
					})
				}
			}
			enterpriseSettings = append(enterpriseSettings, &model.EnterpriseSettings{
				EnterpriseUnitID: &enterpriseSettingRef.EnterpriseUnitID,
				ConfigurationSetID: &model.ConfigurationSetID{
					Name: &enterpriseSettingRef.ConfigurationSetID.Name,
				},
				ConfigurationSettings: configurationSettings,
			})
		}
	}
	for _, hour := range site.Hours {
		hourRef := hour
		hours = append(hours, &model.Hours{
			Close: &model.Close{
				Day:  &hourRef.Close.Day,
				Time: &hourRef.Close.Time,
			},
			Open: &model.Open{
				Day:  &hourRef.Open.Day,
				Time: &hourRef.Open.Time,
			},
		})
	}
	for k, v := range site.Contacts {
		contacts = append(contacts, &model.Contacts{
			Identifier: k,
			Details: &model.Contact{
				Email:                  &v.Email,
				ContactPerson:          &v.ContactPerson,
				PhoneNumber:            &v.PhoneNumber,
				PhoneNumberCountryCode: &v.PhoneNumberCountryCode,
			},
		},
		)
	}
	return &model.StoreSiteInfo{
		SiteName:           site.SiteName,
		Status:             site.Status,
		EnterpriseUnitName: site.EnterpriseUnitName,
		Coordinates: &model.Coordinates{
			Latitude:  site.Coordinates.Latitude,
			Longitude: site.Coordinates.Longitude,
		},
		Description:            &site.Description,
		ID:                     &site.ID,
		ReferenceID:            &site.ReferenceID,
		TimeZone:               &site.TimeZone,
		ParentEnterpriseUnitID: &site.ParentEnterpriseUnitID,
		OrganizationName:       &site.OrganizationName,
		Locked:                 &site.Locked,
		LastModifiedOn:         &site.LastModifiedOn,
		DeactivatedOn:          &site.DeactivatedOn,
		CreatedOn:              &site.CreatedOn,
		Currency:               &site.Currency,
		Contact: &model.Contact{
			ContactPerson:          &site.Contact.ContactPerson,
			PhoneNumberCountryCode: &site.Contact.PhoneNumberCountryCode,
			PhoneNumber:            &site.Contact.PhoneNumber,
		},
		Contacts: contacts,
		Address: &model.Address{
			Street:     &site.Address.Street,
			City:       &site.Address.City,
			State:      &site.Address.State,
			PostalCode: &site.Address.PostalCode,
			Country:    &site.Address.Country,
		},
		Dayparts:            dayparts,
		CustomAttributeSets: customAttributeSets,
		EnterpriseSettings:  enterpriseSettings,
		Hours:               hours,
	}
}

func ToBSLInfo(site *model.StoreSiteInfo) *bsl.BSLInfo { //nolint gocyclo
	defaultValue := ""
	defaultBool := false
	dayparts := make([]bsl.DayParts, 0)
	customAttributeSets := make([]bsl.CustomAttributeSet, 0)
	enterpriseSettings := make([]bsl.EnterpriseSetting, 0)
	hours := make([]bsl.Hours, 0)
	contacts := make(map[string]bsl.Contact)
	if utils.IsNullOrEmpty(site.ID) {
		site.ID = &defaultValue
	}
	if utils.IsNullOrEmpty(site.Description) {
		site.Description = &defaultValue
	}
	if utils.IsNullOrEmpty(site.OrganizationName) {
		site.OrganizationName = &defaultValue
	}
	if utils.IsNullOrEmpty(site.ParentEnterpriseUnitID) {
		site.ParentEnterpriseUnitID = &defaultValue
	}
	if utils.IsNullOrEmpty(site.ReferenceID) {
		site.ReferenceID = &defaultValue
	}
	if len(site.Dayparts) > 0 { //nolint nestif
		for _, daypart := range site.Dayparts {
			daypartRef := daypart
			if utils.IsNullOrEmpty(daypartRef.Day) {
				daypartRef.Day = &defaultValue
			}
			if utils.IsNullOrEmpty(daypartRef.Description) {
				daypartRef.Description = &defaultValue
			}
			if utils.IsNullOrEmpty(daypartRef.Name) {
				daypartRef.Name = &defaultValue
			}
			if utils.IsNullOrEmpty(daypartRef.StartTime) {
				daypartRef.StartTime = &defaultValue
			}
			if utils.IsNullOrEmpty(daypartRef.EndTime) {
				daypartRef.EndTime = &defaultValue
			}
			dayparts = append(dayparts, bsl.DayParts{
				Name:        *daypartRef.Name,
				Description: *daypartRef.Description,
				Day:         *daypartRef.Day,
				StartTime:   *daypartRef.StartTime,
				EndTime:     *daypartRef.EndTime,
			})
		}
	}
	if site.Coordinates == nil {
		site.Coordinates = &model.Coordinates{
			Latitude:  DefaultLatitude,
			Longitude: DefaultLongitude,
		}
	}
	if site.Address != nil && utils.IsNullOrEmpty(site.Address.Street) {
		site.Address.Street = &defaultValue
	}
	if site.Address != nil && utils.IsNullOrEmpty(site.Address.City) {
		site.Address.City = &defaultValue
	}
	if site.Address != nil && utils.IsNullOrEmpty(site.Address.State) {
		site.Address.State = &defaultValue
	}
	if site.Address != nil && utils.IsNullOrEmpty(site.Address.Country) {
		site.Address.Country = &defaultValue
	}
	if site.Address != nil && utils.IsNullOrEmpty(site.Address.PostalCode) {
		site.Address.PostalCode = &defaultValue
	}
	if site.Address == nil {
		site.Address = &model.Address{
			City:       &defaultValue,
			Street:     &defaultValue,
			State:      &defaultValue,
			Country:    &defaultValue,
			PostalCode: &defaultValue,
		}
	}
	if site.Contact != nil && utils.IsNullOrEmpty(site.Contact.ContactPerson) {
		site.Contact.ContactPerson = &defaultValue
	}
	if site.Contact != nil && utils.IsNullOrEmpty(site.Contact.PhoneNumber) {
		site.Contact.PhoneNumber = &defaultValue
	}
	if site.Contact != nil && utils.IsNullOrEmpty(site.Contact.PhoneNumberCountryCode) {
		site.Contact.PhoneNumberCountryCode = &defaultValue
	}
	if site.Contact == nil {
		site.Contact = &model.Contact{
			ContactPerson:          &defaultValue,
			PhoneNumber:            &defaultValue,
			PhoneNumberCountryCode: &defaultValue,
		}
	}
	if utils.IsNullOrEmpty(site.Currency) {
		site.Currency = &defaultValue
	}
	if utils.IsNullOrEmpty(site.DeactivatedOn) {
		site.DeactivatedOn = &defaultValue
	}
	if utils.IsNullOrEmpty(site.LastModifiedOn) {
		site.LastModifiedOn = &defaultValue
	}
	if site.Locked == nil {
		site.Locked = &defaultBool
	}
	if utils.IsNullOrEmpty(site.CreatedOn) {
		site.CreatedOn = &defaultValue
	}
	if utils.IsNullOrEmpty(site.TimeZone) {
		site.TimeZone = &defaultValue
	}
	if len(site.CustomAttributeSets) > 0 { //nolint nestif
		for _, _customAttributeSet := range site.CustomAttributeSets {
			customAttributeSetRef := _customAttributeSet
			customAttribute := make([]bsl.Attribute, 0)
			if utils.IsNullOrEmpty(customAttributeSetRef.TypeName) {
				customAttributeSetRef.TypeName = &defaultValue
			}
			if len(customAttributeSetRef.Attributes) > 0 {
				for _, attribute := range customAttributeSetRef.Attributes {
					attributeRef := attribute
					if utils.IsNullOrEmpty(attributeRef.Key) {
						attributeRef.Key = &defaultValue
					}
					if utils.IsNullOrEmpty(attributeRef.Value) {
						attributeRef.Value = &defaultValue
					}
					customAttribute = append(customAttribute, bsl.Attribute{
						Key:   *attributeRef.Key,
						Value: *attributeRef.Value,
					})
				}
			}
			customAttributeSets = append(customAttributeSets, bsl.CustomAttributeSet{
				TypeName:   *customAttributeSetRef.TypeName,
				Attributes: customAttribute,
			})
		}
	}
	if len(site.EnterpriseSettings) > 0 { //nolint nestif
		for _, enterpriseSetting := range site.EnterpriseSettings {
			configurationSettings := make([]bsl.ConfigurationSetting, 0)
			if utils.IsNullOrEmpty(enterpriseSetting.EnterpriseUnitID) {
				enterpriseSetting.EnterpriseUnitID = &defaultValue
			}
			if enterpriseSetting.ConfigurationSetID != nil && utils.IsNullOrEmpty(enterpriseSetting.ConfigurationSetID.Name) {
				enterpriseSetting.ConfigurationSetID.Name = &defaultValue
			}
			if enterpriseSetting.ConfigurationSetID == nil {
				enterpriseSetting.ConfigurationSetID = &model.ConfigurationSetID{
					Name: &defaultValue,
				}
			}
			if len(enterpriseSetting.ConfigurationSettings) > 0 {
				for _, configurationSetting := range enterpriseSetting.ConfigurationSettings {
					configurationSettingRef := configurationSetting
					if utils.IsNullOrEmpty(configurationSettingRef.Key) {
						configurationSettingRef.Key = &defaultValue
					}
					if utils.IsNullOrEmpty(configurationSettingRef.Value) {
						configurationSettingRef.Value = &defaultValue
					}
					configurationSettings = append(configurationSettings, bsl.ConfigurationSetting{
						Key:   *configurationSettingRef.Key,
						Value: *configurationSettingRef.Value,
					})
				}
			}
			enterpriseSettings = append(enterpriseSettings, bsl.EnterpriseSetting{
				EnterpriseUnitID: *enterpriseSetting.EnterpriseUnitID,
				ConfigurationSetID: bsl.ConfigurationSetID{
					Name: *enterpriseSetting.ConfigurationSetID.Name,
				},
				ConfigurationSettings: configurationSettings,
			})
		}
	}
	if len(site.Hours) > 0 { //nolint nestif
		for _, hour := range site.Hours {
			hourRef := hour
			if hourRef.Close != nil && utils.IsNullOrEmpty(hourRef.Close.Day) {
				hourRef.Close.Day = &defaultValue
			}
			if hourRef.Close != nil && utils.IsNullOrEmpty(hourRef.Close.Time) {
				hourRef.Close.Time = &defaultValue
			}
			if hourRef.Close == nil {
				hourRef.Close = &model.Close{}
			}
			if hourRef.Open != nil && utils.IsNullOrEmpty(hourRef.Open.Day) {
				hourRef.Open.Day = &defaultValue
			}
			if hourRef.Open != nil && utils.IsNullOrEmpty(hourRef.Open.Time) {
				hourRef.Open.Time = &defaultValue
			}
			if hourRef.Open == nil {
				hourRef.Open = &model.Open{}
			}
			hours = append(hours, bsl.Hours{
				Close: bsl.SiteHours{
					Day:  *hourRef.Close.Day,
					Time: *hourRef.Close.Time,
				},
				Open: bsl.SiteHours{
					Day:  *hourRef.Open.Day,
					Time: *hourRef.Open.Time,
				},
			})
		}
	}
	for _, contact := range site.Contacts {
		if contact != nil && contact.Details != nil {
			contacts[contact.Identifier] = bsl.Contact{
				Email:                  *contact.Details.Email,
				ContactPerson:          *contact.Details.ContactPerson,
				PhoneNumber:            *contact.Details.PhoneNumber,
				PhoneNumberCountryCode: *contact.Details.PhoneNumberCountryCode,
			}
		}
	}
	return &bsl.BSLInfo{
		ID:                     *site.ID,
		SiteName:               site.SiteName,
		EnterpriseUnitName:     site.EnterpriseUnitName,
		Description:            *site.Description,
		OrganizationName:       *site.OrganizationName,
		ParentEnterpriseUnitID: *site.ParentEnterpriseUnitID,
		ReferenceID:            *site.ReferenceID,
		DayParts:               dayparts,
		Coordinates: bsl.Coordinates{
			Latitude:  site.Coordinates.Latitude,
			Longitude: site.Coordinates.Longitude,
		},
		Address: bsl.Address{
			Street:     *site.Address.Street,
			City:       *site.Address.City,
			State:      *site.Address.State,
			Country:    *site.Address.Country,
			PostalCode: *site.Address.PostalCode,
		},
		Contact: bsl.Contact{
			ContactPerson:          *site.Contact.ContactPerson,
			PhoneNumber:            *site.Contact.PhoneNumber,
			PhoneNumberCountryCode: *site.Contact.PhoneNumberCountryCode,
		},
		Contacts:            contacts,
		Currency:            *site.Currency,
		DeactivatedOn:       *site.DeactivatedOn,
		LastModifiedOn:      *site.LastModifiedOn,
		Locked:              *site.Locked,
		Status:              site.Status,
		CreatedOn:           *site.CreatedOn,
		TimeZone:            *site.TimeZone,
		CustomAttributeSets: customAttributeSets,
		EnterpriseSettings:  enterpriseSettings,
		Hours:               hours,
	}
}

// ToBSLSite2 converts and maps a model site to a types bslsite2.
func ToBSLSite(site *model.Site, currentSite *types.BslSite) *types.BslSite {
	updatedSite := types.BslSite{
		SiteName:               currentSite.SiteName,
		Status:                 currentSite.Status,
		EnterpriseUnitName:     currentSite.EnterpriseUnitName,
		Coordinates:            currentSite.Coordinates,
		Description:            currentSite.Description,
		ReferenceID:            currentSite.ReferenceID,
		TimeZone:               currentSite.TimeZone,
		ParentEnterpriseUnitID: currentSite.ParentEnterpriseUnitID,
		Locked:                 currentSite.Locked,
		Currency:               currentSite.Currency,
		Address:                currentSite.Address,
		Contact:                currentSite.Contact,
		Dayparts:               currentSite.Dayparts,
		CustomAttributeSets:    currentSite.CustomAttributeSets,
		Hours:                  currentSite.Hours,
		Contacts:               currentSite.Contacts,
	}

	if site.SiteName != nil {
		updatedSite.SiteName = *site.SiteName
	}
	if site.Status != nil {
		updatedSite.Status = *site.Status
	}
	if site.EnterpriseUnitName != nil {
		updatedSite.EnterpriseUnitName = *site.EnterpriseUnitName
	}
	if site.Coordinates != nil {
		updatedSite.Coordinates = types.Coordinates(*site.Coordinates)
	}
	if site.Description != nil {
		if *site.Description == "" {
			updatedSite.Description = nil
		} else {
			updatedSite.Description = site.Description
		}
	}
	if site.ReferenceID != nil {
		if *site.ReferenceID == "" {
			updatedSite.ReferenceID = nil
		} else {
			updatedSite.ReferenceID = site.ReferenceID
		}
	}
	if site.TimeZone != nil {
		updatedSite.TimeZone = site.TimeZone
	}
	if site.ParentEnterpriseUnitID != nil {
		updatedSite.ParentEnterpriseUnitID = site.ParentEnterpriseUnitID
	}
	if site.Locked != nil {
		updatedSite.Locked = site.Locked
	}
	if site.Currency != nil {
		updatedSite.Currency = site.Currency
	}
	if site.Address != nil {
		updatedSite.Address = toTypeAddress(site.Address)
	}
	if site.Contact != nil {
		updatedSite.Contact = toTypeContact(site.Contact)
	}
	if site.Dayparts != nil {
		updatedSite.Dayparts = toTypeDayparts(site.Dayparts)
	}
	if site.CustomAttributeSets != nil {
		updatedSite.CustomAttributeSets = toTypeCustomAttributeSets(site.CustomAttributeSets)
	}
	if site.Hours != nil {
		updatedSite.Hours = toTypeHours(site.Hours)
	}
	for _, contact := range site.Contacts {
		if contact != nil {
			c := &types.Contact{}
			if contact.Contact.ContactPerson != nil {
				c.ContactPerson = contact.Contact.ContactPerson
			}
			if contact.Contact.Email != nil {
				c.Email = contact.Contact.Email
			}
			if contact.Contact.PhoneNumber != nil {
				c.PhoneNumber = contact.Contact.PhoneNumber
			}
			if contact.Contact.PhoneNumberCountryCode != nil {
				c.PhoneNumberCountryCode = contact.Contact.PhoneNumberCountryCode
			}
			updatedSite.Contacts[contact.Identifier] = c
		}
	}
	return &updatedSite
}

// toTypeContact converts a model contact input to a type contact.
func toTypeContact(contact *model.ContactInput) *types.Contact {
	return &types.Contact{
		ContactPerson:          contact.ContactPerson,
		PhoneNumber:            contact.PhoneNumber,
		PhoneNumberCountryCode: contact.PhoneNumberCountryCode,
		Email:                  contact.Email,
	}
}

// toTypeAddress converts model address input to types address.
func toTypeAddress(address *model.AddressInput) *types.Address {
	return &types.Address{
		Street:     address.Street,
		City:       address.City,
		State:      address.State,
		Country:    address.Country,
		PostalCode: address.PostalCode,
	}
}

// toTypeDayparts converts a model dayparts input to a types dayparts.
func toTypeDayparts(dayparts []*model.DaypartsInput) []*types.Dayparts {
	typeDayparts := make([]*types.Dayparts, 0)
	defaultVal := ""
	if len(dayparts) > 0 { //nolint complexity
		for _, daypart := range dayparts {
			if utils.IsNullOrEmpty(daypart.Day) {
				daypart.Day = &defaultVal
			}
			if utils.IsNullOrEmpty(daypart.Description) {
				daypart.Description = &defaultVal
			}
			if utils.IsNullOrEmpty(daypart.Name) {
				daypart.Name = &defaultVal
			}
			if utils.IsNullOrEmpty(daypart.StartTime) {
				daypart.StartTime = &defaultVal
			}
			if utils.IsNullOrEmpty(daypart.EndTime) {
				daypart.EndTime = &defaultVal
			}
			typeDayparts = append(typeDayparts, &types.Dayparts{
				Day:         daypart.Day,
				Description: daypart.Description,
				Name:        daypart.Name,
				StartTime:   daypart.StartTime,
				EndTime:     daypart.EndTime,
			})
		}
	}
	return typeDayparts
}

// toTypeCustomAttributeSets converts model custom attribute sets to types custom attribute sets.
func toTypeCustomAttributeSets(customAttributeSets []*model.CustomAttributeSetsInput) []*types.CustomAttributeSets {
	typeCustomAttributeSets := make([]*types.CustomAttributeSets, 0)
	defaultVal := ""
	if len(customAttributeSets) > 0 { //nolint complexity
		for _, customAttributeSet := range customAttributeSets {
			typeAttributes := make([]*types.Attributes, 0)
			if len(customAttributeSet.Attributes) > 0 {
				for _, customAttributeSetVal := range customAttributeSet.Attributes {
					if utils.IsNullOrEmpty(customAttributeSetVal.Key) {
						customAttributeSetVal.Key = &defaultVal
					}
					if utils.IsNullOrEmpty(customAttributeSetVal.Value) {
						customAttributeSetVal.Value = &defaultVal
					}
					typeAttributes = append(typeAttributes, &types.Attributes{
						Key:   customAttributeSetVal.Key,
						Value: customAttributeSetVal.Value,
					})
				}
			}
			typeCustomAttributeSets = append(typeCustomAttributeSets, &types.CustomAttributeSets{
				TypeName:   customAttributeSet.TypeName,
				Attributes: typeAttributes,
			})
		}
	}
	return typeCustomAttributeSets
}

// toTypeHours converts model hour input to type hour without setting default values.
func toTypeHours(hours []*model.HoursInput) []*types.Hours {
	typeHours := make([]*types.Hours, 0)
	if len(hours) > 0 {
		for _, hour := range hours {
			hour := hour
			typeHours = append(typeHours, &types.Hours{
				Close: &types.Close{
					Day:  hour.Close.Day,
					Time: hour.Close.Time,
				},
				Open: &types.Open{
					Day:  hour.Open.Day,
					Time: hour.Open.Time,
				},
			})
		}
	}
	return typeHours
}