package mapper_test

import (
	"testing"

	"github.com/stretchr/testify/assert"

	"edge-infra.dev/pkg/edge/api/bsl/types"
	"edge-infra.dev/pkg/edge/api/graph/mapper"
	"edge-infra.dev/pkg/edge/api/graph/model"
	"edge-infra.dev/pkg/edge/api/services"
)

var (
	siteName                = "Test Site"
	status                  = services.ActiveStatus
	description             = "Test site description"
	referenceID             = "test-site-id"
	timezone                = "UTC"
	parentEnterpriseUnitID  = "parent"
	locked                  = false
	currency                = "USD"
	contactPerson           = "John Doe"
	phoneNumber             = "1234567891"
	countryCode             = "+1"
	street                  = "1 Test Street"
	city                    = "Oklahoma City"
	state                   = "Oklahoma"
	country                 = "US"
	postalCode              = "74464"
	daypartsName            = "Hours of Operation"
	dayOne                  = "Monday"
	startTimeOne            = "8am"
	endTimeOne              = "5pm"
	dayTwo                  = "Tuesday"
	startTimeTwo            = "7am"
	endTimeTwo              = "4pm"
	customAttributeTypeName = "Test Attribute"
	key                     = "key"
	value                   = "value"
)

func TestToBSLSiteNoContactPhoneNumberFields(t *testing.T) {
	siteName := "site-no-phone"

	site := &model.Site{
		SiteName:           &siteName,
		EnterpriseUnitName: &siteName,
		Status:             &status,
		Coordinates: &model.CoordinatesInput{
			Latitude:  90.0,
			Longitude: 180.0,
		},
		Locked: &locked,
		Contact: &model.ContactInput{
			ContactPerson: &contactPerson,
		},
	}
	typesSite := mapper.ToBSLSite(site, &types.BslSite{
		Locked: &locked,
	})
	assert.NotEmpty(t, typesSite)
	assert.Equal(t, site.Coordinates.Latitude, typesSite.Coordinates.Latitude)
	assert.Equal(t, site.Coordinates.Longitude, typesSite.Coordinates.Longitude)

	assert.Equal(t, site.Contact.ContactPerson, typesSite.Contact.ContactPerson)
	assert.Nil(t, typesSite.Contact.PhoneNumber)
	assert.Nil(t, typesSite.Contact.PhoneNumberCountryCode, nil)
}

func TestToBSLSiteNoContactPersonFields(t *testing.T) {
	siteName := "site-no-person"

	site := &model.Site{
		SiteName:           &siteName,
		EnterpriseUnitName: &siteName,
		Status:             &status,
		Coordinates: &model.CoordinatesInput{
			Latitude:  90.0,
			Longitude: 180.0,
		},
		Locked: &locked,
		Contact: &model.ContactInput{
			PhoneNumber:            &phoneNumber,
			PhoneNumberCountryCode: &countryCode,
		},
	}
	typesSite := mapper.ToBSLSite(site, &types.BslSite{
		Locked: &locked,
	})
	assert.NotEmpty(t, typesSite)
	assert.Equal(t, site.Coordinates.Latitude, typesSite.Coordinates.Latitude)
	assert.Equal(t, site.Coordinates.Longitude, typesSite.Coordinates.Longitude)

	assert.Nil(t, typesSite.Contact.ContactPerson)
	assert.Equal(t, site.Contact.PhoneNumber, typesSite.Contact.PhoneNumber)
	assert.Equal(t, site.Contact.PhoneNumberCountryCode, typesSite.Contact.PhoneNumberCountryCode)
}

func TestToBSLSiteFullFields(t *testing.T) {
	site := &model.Site{
		SiteName:           &siteName,
		Status:             &status,
		EnterpriseUnitName: &siteName,
		Coordinates: &model.CoordinatesInput{
			Latitude:  90.0,
			Longitude: 180.0,
		},
		Description:            &description,
		ReferenceID:            &referenceID,
		TimeZone:               &timezone,
		ParentEnterpriseUnitID: &parentEnterpriseUnitID,
		Locked:                 &locked,
		Currency:               &currency,
		Contact: &model.ContactInput{
			ContactPerson:          &contactPerson,
			PhoneNumber:            &phoneNumber,
			PhoneNumberCountryCode: &countryCode,
		},
		Address: &model.AddressInput{
			Street:     &street,
			City:       &city,
			State:      &state,
			Country:    &country,
			PostalCode: &postalCode,
		},
		Dayparts: []*model.DaypartsInput{
			{
				Name:        &daypartsName,
				Day:         &dayOne,
				Description: &description,
				StartTime:   &startTimeOne,
				EndTime:     &endTimeOne,
			},
		},
		CustomAttributeSets: []*model.CustomAttributeSetsInput{
			{
				TypeName: &customAttributeTypeName,
				Attributes: []*model.AttributesInput{
					{
						Key:   &key,
						Value: &value,
					},
				},
			},
		},
		Hours: []*model.HoursInput{
			{
				Close: &model.CloseInput{
					Day:  &dayOne,
					Time: &endTimeOne,
				},
				Open: &model.OpenInput{
					Day:  &dayOne,
					Time: &startTimeOne,
				},
			},
			{
				Close: &model.CloseInput{
					Day:  &dayTwo,
					Time: &endTimeTwo,
				},
				Open: &model.OpenInput{
					Day:  &dayTwo,
					Time: &startTimeTwo,
				},
			},
		},
	}
	typesSite := mapper.ToBSLSite(site, &types.BslSite{})
	assert.NotEmpty(t, typesSite)

	assert.Equal(t, *site.SiteName, typesSite.SiteName)
	assert.Equal(t, *site.Status, typesSite.Status)
	assert.Equal(t, *site.EnterpriseUnitName, typesSite.EnterpriseUnitName)
	assert.Equal(t, site.Coordinates.Latitude, typesSite.Coordinates.Latitude)
	assert.Equal(t, site.Coordinates.Longitude, typesSite.Coordinates.Longitude)
	assert.Equal(t, site.Description, typesSite.Description)
	assert.Equal(t, site.ReferenceID, typesSite.ReferenceID)
	assert.Equal(t, site.TimeZone, typesSite.TimeZone)
	assert.Equal(t, site.ParentEnterpriseUnitID, typesSite.ParentEnterpriseUnitID)
	assert.Equal(t, site.Locked, typesSite.Locked)
	assert.Equal(t, site.Currency, typesSite.Currency)
	assert.Equal(t, site.Contact.ContactPerson, typesSite.Contact.ContactPerson)
	assert.Equal(t, site.Contact.PhoneNumber, typesSite.Contact.PhoneNumber)
	assert.Equal(t, site.Contact.PhoneNumberCountryCode, typesSite.Contact.PhoneNumberCountryCode)
	assert.Equal(t, site.Address.Street, typesSite.Address.Street)
	assert.Equal(t, site.Address.City, typesSite.Address.City)
	assert.Equal(t, site.Address.State, typesSite.Address.State)
	assert.Equal(t, site.Address.Country, typesSite.Address.Country)
	assert.Equal(t, site.Address.PostalCode, typesSite.Address.PostalCode)
	assert.Equal(t, site.Dayparts[0].Name, typesSite.Dayparts[0].Name)
	assert.Equal(t, site.Dayparts[0].Day, typesSite.Dayparts[0].Day)
	assert.Equal(t, site.Dayparts[0].Description, typesSite.Dayparts[0].Description)
	assert.Equal(t, site.Dayparts[0].StartTime, typesSite.Dayparts[0].StartTime)
	assert.Equal(t, site.Dayparts[0].EndTime, typesSite.Dayparts[0].EndTime)
	assert.Equal(t, site.CustomAttributeSets[0].TypeName, typesSite.CustomAttributeSets[0].TypeName)
	assert.Equal(t, site.CustomAttributeSets[0].Attributes[0].Key, typesSite.CustomAttributeSets[0].Attributes[0].Key)
	assert.Equal(t, site.CustomAttributeSets[0].Attributes[0].Value, typesSite.CustomAttributeSets[0].Attributes[0].Value)
	assert.Equal(t, site.Hours[0].Open.Day, typesSite.Hours[0].Open.Day)
	assert.Equal(t, site.Hours[0].Open.Time, typesSite.Hours[0].Open.Time)
	assert.Equal(t, site.Hours[0].Close.Day, typesSite.Hours[0].Close.Day)
	assert.Equal(t, site.Hours[0].Close.Time, typesSite.Hours[0].Close.Time)
	assert.Equal(t, site.Hours[1].Open.Day, typesSite.Hours[1].Open.Day)
	assert.Equal(t, site.Hours[1].Open.Time, typesSite.Hours[1].Open.Time)
	assert.Equal(t, site.Hours[1].Close.Day, typesSite.Hours[1].Close.Day)
	assert.Equal(t, site.Hours[1].Close.Time, typesSite.Hours[1].Close.Time)
}

func TestToBSLSite2MissingFields(t *testing.T) {
	defaultValue := ""
	site := &model.Site{
		Description: &defaultValue,
		ReferenceID: &defaultValue,
	}
	currentSite := &types.BslSite{
		SiteName:           siteName,
		Status:             status,
		EnterpriseUnitName: siteName,
		Coordinates: types.Coordinates{
			Latitude:  90.0,
			Longitude: 180.0,
		},
		Description:            &description,
		ReferenceID:            &referenceID,
		TimeZone:               &timezone,
		ParentEnterpriseUnitID: &parentEnterpriseUnitID,
		Currency:               &currency,
		Contact: &types.Contact{
			ContactPerson:          &contactPerson,
			PhoneNumberCountryCode: &countryCode,
		},
		Address: &types.Address{
			Street: &street,
			State:  &state,
		},
		Dayparts: []*types.Dayparts{
			{
				Name:    &daypartsName,
				Day:     &dayOne,
				EndTime: &endTimeOne,
			},
		},
		CustomAttributeSets: []*types.CustomAttributeSets{
			{
				TypeName: &customAttributeTypeName,
			},
		},
		Hours: []*types.Hours{
			{
				Close: &types.Close{
					Day:  &dayOne,
					Time: &endTimeOne,
				},
				Open: &types.Open{
					Day:  &dayOne,
					Time: &startTimeOne,
				},
			},
		},
	}
	typesSite := mapper.ToBSLSite(site, currentSite)
	assert.NotEmpty(t, typesSite)

	assert.Equal(t, siteName, typesSite.SiteName)
	assert.Equal(t, status, typesSite.Status)
	assert.Equal(t, siteName, typesSite.EnterpriseUnitName)
	assert.Equal(t, services.DefaultLatitude, typesSite.Coordinates.Latitude)
	assert.Equal(t, services.DefaultLongitude, typesSite.Coordinates.Longitude)
	assert.Equal(t, timezone, *typesSite.TimeZone)
	assert.Equal(t, parentEnterpriseUnitID, *typesSite.ParentEnterpriseUnitID)
	assert.Equal(t, currency, *typesSite.Currency)
	assert.Equal(t, contactPerson, *typesSite.Contact.ContactPerson)
	assert.Equal(t, countryCode, *typesSite.Contact.PhoneNumberCountryCode)
	assert.Equal(t, street, *typesSite.Address.Street)
	assert.Equal(t, state, *typesSite.Address.State)
	assert.Equal(t, daypartsName, *typesSite.Dayparts[0].Name)
	assert.Equal(t, dayOne, *typesSite.Dayparts[0].Day)
	assert.Equal(t, endTimeOne, *typesSite.Dayparts[0].EndTime)
	assert.Equal(t, customAttributeTypeName, *typesSite.CustomAttributeSets[0].TypeName)
	assert.Equal(t, startTimeOne, *typesSite.Hours[0].Open.Time)
	assert.Equal(t, dayOne, *typesSite.Hours[0].Close.Day)

	assert.Nil(t, typesSite.Description)
	assert.Nil(t, typesSite.ReferenceID)
}