package addressesService

import (
	"encoding/json"
	"fmt"
	"strings"

	"git.ma-al.com/goc_daniel/b2b/app/model"
	"git.ma-al.com/goc_daniel/b2b/app/repos/addressesRepo"
	constdata "git.ma-al.com/goc_daniel/b2b/app/utils/const_data"
	"git.ma-al.com/goc_daniel/b2b/app/utils/responseErrors"
)

type AddressesService struct {
	repo addressesRepo.UIAddressesRepo
}

func New() *AddressesService {
	return &AddressesService{
		repo: addressesRepo.New(),
	}
}

func (s *AddressesService) GetTemplate(country_id uint) (model.AddressUnparsed, error) {
	switch country_id {

	case 1: // Poland
		return model.AddressPL{}, nil

	case 2: // Great Britain
		return model.AddressGB{}, nil

	case 3: // Czech Republic
		return model.AddressCZ{}, nil

	case 4: // Germany
		return model.AddressDE{}, nil

	default:
		return nil, responseErrors.ErrInvalidCountryID
	}
}

func (s *AddressesService) AddNewAddress(user_id uint, address_info string, country_id uint) error {
	amt, err := s.repo.UserAddressesAmt(user_id)
	if err != nil {
		return err
	} else if amt >= constdata.MAX_AMOUNT_OF_ADDRESSES_PER_USER {
		return responseErrors.ErrMaxAmtOfAddressesReached
	}

	_, err = s.ValidateAddressJson(address_info, country_id)
	if err != nil {
		return err
	}

	return s.repo.AddNewAddress(user_id, address_info, country_id)
}

// country_id = 0 means that country_id remains unchanged
func (s *AddressesService) ModifyAddress(user_id uint, address_id uint, address_info string, country_id uint) error {
	amt, err := s.repo.UserHasAddress(user_id, address_id)
	if err != nil {
		return err
	} else if amt != 1 {
		return responseErrors.ErrUserHasNoSuchAddress
	}

	_, err = s.ValidateAddressJson(address_info, country_id)
	if err != nil {
		return err
	}

	return s.repo.UpdateAddress(user_id, address_id, address_info, country_id)
}

func (s *AddressesService) RetrieveAddresses(user_id uint) (*[]model.Address, error) {
	addresses, err := s.repo.RetrieveAddresses(user_id)
	if err != nil {
		return nil, err
	}

	for i := 0; i < len(*addresses); i++ {
		address_unparsed, err := s.ValidateAddressJson((*addresses)[i].AddressString, (*addresses)[i].CountryID)
		// log such errors
		if err != nil {
			fmt.Printf("err: %v\n", err)
		}

		(*addresses)[i].AddressUnparsed = &address_unparsed
	}

	return addresses, nil
}

func (s *AddressesService) DeleteAddress(user_id uint, address_id uint) error {
	amt, err := s.repo.UserHasAddress(user_id, address_id)
	if err != nil {
		return err
	} else if amt != 1 {
		return responseErrors.ErrUserHasNoSuchAddress
	}

	return s.repo.DeleteAddress(user_id, address_id)
}

// validateAddressJson makes sure that the info string represents a valid json of address in given country
func (s *AddressesService) ValidateAddressJson(info string, country_id uint) (model.AddressUnparsed, error) {
	dec := json.NewDecoder(strings.NewReader(info))
	dec.DisallowUnknownFields()

	switch country_id {

	case 1: // Poland
		var address model.AddressPL
		if err := dec.Decode(&address); err != nil {
			return address, responseErrors.ErrInvalidAddressJSON
		}
		return address, nil

	case 2: // Great Britain
		var address model.AddressGB
		if err := dec.Decode(&address); err != nil {
			return address, responseErrors.ErrInvalidAddressJSON
		}
		return address, nil

	case 3: // Czech Republic
		var address model.AddressCZ
		if err := dec.Decode(&address); err != nil {
			return address, responseErrors.ErrInvalidAddressJSON
		}
		return address, nil

	case 4: // Germany
		var address model.AddressDE
		if err := dec.Decode(&address); err != nil {
			return address, responseErrors.ErrInvalidAddressJSON
		}
		return address, nil

	default:
		return nil, responseErrors.ErrInvalidCountryID
	}
}