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.AddressField, 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) RetrieveAddressesInfo(user_id uint) (*[]model.AddressUnparsed, error) {
	parsed_addresses, err := s.repo.RetrieveAddresses(user_id)
	if err != nil {
		return nil, err
	}

	var unparsed_addresses []model.AddressUnparsed

	for i := 0; i < len(*parsed_addresses); i++ {
		var next_address model.AddressUnparsed
		next_address.ID = (*parsed_addresses)[i].ID
		next_address.CustomerID = (*parsed_addresses)[i].CustomerID
		next_address.CountryID = (*parsed_addresses)[i].CountryID

		next_address.AddressInfo, err = s.validateAddressJson((*parsed_addresses)[i].AddressInfo, next_address.CountryID)
		// log such errors
		if err != nil {
			fmt.Printf("err: %v\n", err)
		}

		unparsed_addresses = append(unparsed_addresses, next_address)
	}

	return &unparsed_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.AddressField, 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
	}
}