Boostport/address

package address

import (
    "regexp"
    "strconv"
    "strings"
)

// Zone is a list of territories. Zones are useful for determining whether an address is in a country, administrative area
// or a range of post codes to determine shipping or tax rates.
type Zone []Territory

// Contains checks to see an address is in a zone.
func (z Zone) Contains(address Address) bool {
    for _, zone := range z {
        if zone.contains(address) {
            return true
        }
    }

    return false
}

// Territory is a rule within a zone.
// It is able to match the following fields:
// - Country: An ISO 3166-1 country code
// - AdministrativeArea: The administrative area name. If the country has a list of pre-defined administrative areas,
// use the key of the administrative area.
// - Locality: The locality name. If the country has a list of pre-defined localities, use the key of the locality.
// - DependentLocality: The dependent locality name. If the country has a list of pre-defined dependent localities,
// use the key of the locality.
// - IncludedPostCodes: A PostCodeMatcher that includes the address within the territory if the post code matches.
// - ExcludedPostCodes: A PostCodeMatcher that excludes the address from the territory if the post code matches.
type Territory struct {
    Country            string
    AdministrativeArea string
    Locality           string
    DependentLocality  string
    IncludedPostCodes  PostCodeMatcher
    ExcludedPostCodes  PostCodeMatcher
}

// PostCodeMatcher returns a boolean signaling whether the post code matched or not.
type PostCodeMatcher interface {
    Match(postcode string) bool
}

func (t Territory) contains(address Address) bool {

    if t.Country != "" && address.Country != t.Country {
        return false
    }

    if t.AdministrativeArea != "" && strings.ToLower(address.AdministrativeArea) != strings.ToLower(t.AdministrativeArea) {
        return false
    }

    if t.Locality != "" && strings.ToLower(address.Locality) != strings.ToLower(t.Locality) {
        return false
    }

    if t.DependentLocality != "" && strings.ToLower(address.DependentLocality) != strings.ToLower(t.DependentLocality) {
        return false
    }

    matchIncluded := true

    if t.IncludedPostCodes != nil {

        matchIncluded = t.IncludedPostCodes.Match(address.PostCode)
    }

    matchExcluded := false

    if t.ExcludedPostCodes != nil {
        matchExcluded = t.ExcludedPostCodes.Match(address.PostCode)
    }

    return matchIncluded && !matchExcluded
}

// ExactMatcher matches post codes exactly in the list defined in the Matches field. If the post code is numeric,
// it's also possible to define a slice of ranges using the Ranges fiel.d
type ExactMatcher struct {
    Matches []string
    Ranges  []PostCodeRange
}

// Match checks to see if the post code matches a post code defined in Matches or if it is within a range defined in Ranges.
func (m ExactMatcher) Match(postCode string) bool {
    for _, match := range m.Matches {
        if postCode == match {
            return true
        }
    }

    i, err := strconv.Atoi(postCode)

    if err != nil {
        return false
    }

    for _, match := range m.Ranges {
        if i >= match.Start && i <= match.End {
            return true
        }
    }

    return false
}

// PostCodeRange defines a range of numeric post codes, inclusive of the Start and End.
type PostCodeRange struct {
    Start int
    End   int
}

// RegexMatcher defines a post code matcher that uses a regular expression.
type RegexMatcher struct {
    Regex *regexp.Regexp
}

// Match returns whether the post code is matched by the regular expression defined in the matcher.
func (m RegexMatcher) Match(postCode string) bool {
    return m.Regex.MatchString(postCode)
}