package apifraud

/**
 * Generated by API Builder - https://www.apibuilder.io
 * Service version: 0.0.2
 * User agent: apibuilder app.apibuilder.io/hbc/api-fraud/0.0.2/go_1_5_client
 */

import (
	"bytes"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"net/http"
	"strconv"
	"strings"
)

const BaseUrl = "http://fraud-frozone"
const UserAgent = "apibuilder app.apibuilder.io/hbc/api-fraud/0.0.2/go_1_5_client"
const Version = "0.0.2"
const VersionMajor = 0

type Client struct {
	HttpClient *http.Client
	Username   string
	Password   string
	BaseUrl    string
	Headers    http.Header
}

type ClientRequestBody struct {
	contentType string
	bytes       io.Reader
}

/**
 * Our lovely store chains
 */
type Banner string

const (
	BannerLat Banner  = "lat"
	BannerS5a         = "s5a"
	BannerO5a         = "o5a"
	BannerBay         = "bay"
	BannerUNDEFINED   = "UNDEFINED"
)

func BannerFromString(value string) Banner {
	switch strings.TrimSpace(strings.ToLower(value)) {
	case "lat":
		return BannerLat
	case "s5a":
		return BannerS5a
	case "o5a":
		return BannerO5a
	case "bay":
		return BannerBay
	default:
		return BannerUNDEFINED
	}
}

/**
 * Possible types of customers
 */
type CustomerType string

const (
	CustomerTypeGuest CustomerType  = "guest"
	CustomerTypeRegistered          = "registered"
	CustomerTypeEmployee            = "employee"
	CustomerTypeUNDEFINED           = "UNDEFINED"
)

func CustomerTypeFromString(value string) CustomerType {
	switch strings.TrimSpace(strings.ToLower(value)) {
	case "guest":
		return CustomerTypeGuest
	case "registered":
		return CustomerTypeRegistered
	case "employee":
		return CustomerTypeEmployee
	default:
		return CustomerTypeUNDEFINED
	}
}

/**
 * Enum describing the possible responses
 */
type RecommendationCode string

const (
	RecommendationCodeReject RecommendationCode  = "reject"
	RecommendationCodeReview                     = "review"
	RecommendationCodeAccept                     = "accept"
	RecommendationCodeUNDEFINED                  = "UNDEFINED"
)

func RecommendationCodeFromString(value string) RecommendationCode {
	switch strings.TrimSpace(strings.ToLower(value)) {
	case "reject":
		return RecommendationCodeReject
	case "review":
		return RecommendationCodeReview
	case "accept":
		return RecommendationCodeAccept
	default:
		return RecommendationCodeUNDEFINED
	}
}

/**
 * Envelope data
 */
type AdditionalData struct {
	InAuthId string `json:"inAuthId"`
}

func AdditionalDataFromMap(data interface{}) AdditionalData {
	b, err := json.Marshal(data)
	if err == nil {
		return AdditionalDataFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func AdditionalDataFromJson(bytes io.Reader) AdditionalData {
	var additionalData AdditionalData
	json.NewDecoder(bytes).Decode(&additionalData)
	return additionalData
}

/**
 * General address model
 */
type Address struct {
	Name          string `json:"name"`
	StreetLineOne string `json:"streetLineOne"`
	StreetLineTwo string `json:"streetLineTwo,omitempty"`
	City          string `json:"city"`
	State         string `json:"state"`
	Zip           string `json:"zip"`
	Country       string `json:"country"`
}

func AddressFromMap(data interface{}) Address {
	b, err := json.Marshal(data)
	if err == nil {
		return AddressFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func AddressFromJson(bytes io.Reader) Address {
	var address Address
	json.NewDecoder(bytes).Decode(&address)
	return address
}

/**
 * A customer's complete credit card information
 */
type CreditCard struct {
	NameOnCard        string  `json:"nameOnCard"`
	BillingAddress    Address `json:"billingAddress"`
	CardType          string  `json:"cardType"`
	CardNumber        string  `json:"cardNumber"`
	AuthorizedAmount  float64 `json:"authorizedAmount"`
	FullAmount        float64 `json:"fullAmount"`
	ExpiryDate        string  `json:"expiryDate"`
	AuthCode          string  `json:"authCode"`
	ResponseCode      int32   `json:"responseCode"`
	MerchantId        int32   `json:"merchantId,omitempty"`
	RegisterNumber    string  `json:"registerNumber,omitempty"`
	TransactionNumber string  `json:"transactionNumber"`
	AvsResponse       string  `json:"avsResponse"`
}

func CreditCardFromMap(data interface{}) CreditCard {
	b, err := json.Marshal(data)
	if err == nil {
		return CreditCardFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func CreditCardFromJson(bytes io.Reader) CreditCard {
	var creditCard CreditCard
	json.NewDecoder(bytes).Decode(&creditCard)
	return creditCard
}

/**
 * Customer model
 */
type Customer struct {
	CustomerType CustomerType `json:"customerType"`
	AccountId    string       `json:"accountId"`
	CreationDate string       `json:"creationDate"`
	FirstName    string       `json:"firstName"`
	LastName     string       `json:"lastName"`
	EmailAddress string       `json:"emailAddress"`
}

func CustomerFromMap(data interface{}) Customer {
	b, err := json.Marshal(data)
	if err == nil {
		return CustomerFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func CustomerFromJson(bytes io.Reader) Customer {
	var customer Customer
	json.NewDecoder(bytes).Decode(&customer)
	return customer
}

/**
 * Response model to OMS containing the transaction they've sent and the decision
 * we've made
 */
type DBRecord struct {
	TransactionId    string      `json:"transactionId"`
	LastModifiedDate string      `json:"lastModifiedDate,omitempty"`
	CreatedDate      string      `json:"createdDate,omitempty"`
	Transaction      Transaction `json:"transaction"`
	Decision         Decision    `json:"decision"`
}

func DBRecordFromMap(data interface{}) DBRecord {
	b, err := json.Marshal(data)
	if err == nil {
		return DBRecordFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func DBRecordFromJson(bytes io.Reader) DBRecord {
	var dBRecord DBRecord
	json.NewDecoder(bytes).Decode(&dBRecord)
	return dBRecord
}

/**
 * Defines decision information
 */
type Decision struct {
	TransactionId      string             `json:"transactionId"`
	RecommendationCode RecommendationCode `json:"recommendationCode"`
	CrossReference     string             `json:"crossReference,omitempty"`
	RulesTripped       string             `json:"rulesTripped,omitempty"`
	TotalScore         int32              `json:"totalScore"`
	Remarks            string             `json:"remarks,omitempty"`
}

func DecisionFromMap(data interface{}) Decision {
	b, err := json.Marshal(data)
	if err == nil {
		return DecisionFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func DecisionFromJson(bytes io.Reader) Decision {
	var decision Decision
	json.NewDecoder(bytes).Decode(&decision)
	return decision
}

/**
 * Error response model
 */
type Error struct {
	Message string `json:"message"`
	Error   string `json:"error"`
}

func ErrorFromMap(data interface{}) Error {
	b, err := json.Marshal(data)
	if err == nil {
		return ErrorFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ErrorFromJson(bytes io.Reader) Error {
	var error_ Error
	json.NewDecoder(bytes).Decode(&error_)
	return error_
}

/**
 * Single item
 */
type Item struct {
	SvsNumber       int32   `json:"svsNumber"`
	SkuNumber       int32   `json:"skuNumber"`
	UpcNumber       int32   `json:"upcNumber,omitempty"`
	ClassNumber     int32   `json:"classNumber,omitempty"`
	Color           string  `json:"color,omitempty"`
	Size            string  `json:"size,omitempty"`
	CurrentStatus   string  `json:"currentStatus"`
	Department      int32   `json:"department"`
	SignOnDelivery  string  `json:"signOnDelivery,omitempty"`
	GiftWrapped     string  `json:"giftWrapped,omitempty"`
	CostAmount      float64 `json:"costAmount,omitempty"`
	MarginAmount    float64 `json:"marginAmount,omitempty"`
	Description     string  `json:"description"`
	Price           float64 `json:"price"`
	ExtendedPrice   float64 `json:"extendedPrice"`
	Quantity        int32   `json:"quantity"`
	GroupNumber     int32   `json:"groupNumber"`
	ShippingAddress Address `json:"shippingAddress"`
	ShippingMethod  string  `json:"shippingMethod"`
	ShippingCountry string  `json:"shippingCountry"`
}

func ItemFromMap(data interface{}) Item {
	b, err := json.Marshal(data)
	if err == nil {
		return ItemFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ItemFromJson(bytes io.Reader) Item {
	var item Item
	json.NewDecoder(bytes).Decode(&item)
	return item
}

/**
 * Promotion model
 */
type Promo struct {
	PromotionCode   string  `json:"promotionCode"`
	PromotionAmount float64 `json:"promotionAmount"`
}

func PromoFromMap(data interface{}) Promo {
	b, err := json.Marshal(data)
	if err == nil {
		return PromoFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func PromoFromJson(bytes io.Reader) Promo {
	var promo Promo
	json.NewDecoder(bytes).Decode(&promo)
	return promo
}

/**
 * Defines data expected to come in from OMS describing a transaction
 */
type Transaction struct {
	OrderId          string         `json:"orderId"`
	GroupId          string         `json:"groupId"`
	OrderTotal       float64        `json:"orderTotal"`
	ShippingCost     float64        `json:"shippingCost"`
	CurrencyCode     string         `json:"currencyCode"`
	StoreNumber      int32          `json:"storeNumber"`
	SalesRep         string         `json:"salesRep,omitempty"`
	LastModifiedDate string         `json:"lastModifiedDate,omitempty"`
	Banner           Banner         `json:"banner"`
	CreditCard       CreditCard     `json:"creditCard"`
	Promos           []Promo        `json:"promos,omitempty"`
	Items            []Item         `json:"items"`
	IpAddress        string         `json:"ipAddress,omitempty"`
	Source           string         `json:"source"`
	Customer         Customer       `json:"customer"`
	AdditionalData   AdditionalData `json:"additionalData,omitempty"`
}

func TransactionFromMap(data interface{}) Transaction {
	b, err := json.Marshal(data)
	if err == nil {
		return TransactionFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func TransactionFromJson(bytes io.Reader) Transaction {
	var transaction Transaction
	json.NewDecoder(bytes).Decode(&transaction)
	return transaction
}

type DecisionsPostResponse struct {
	StatusCode int
	Response   *http.Response
	Error      error
	ErrorS     []Error
}

func DecisionsPost(client Client, decision Decision) DecisionsPostResponse {

	requestUrl := fmt.Sprintf("%s/decision", client.BaseUrl)

	bodyDocument, err := json.Marshal(decision)
	if err != nil {
		return DecisionsPostResponse{Error: err}
	}
	body := ClientRequestBody{contentType: "application/json", bytes: bytes.NewReader(bodyDocument)}

	request, err := buildRequest(client, "POST", requestUrl, body)
	if err != nil {
		return DecisionsPostResponse{Error: err}
	}

	resp, err := client.HttpClient.Do(request)
	if err != nil {
		return DecisionsPostResponse{Error: err}
	}
	defer resp.Body.Close()

	switch resp.StatusCode {
	case 200:
		return DecisionsPostResponse{StatusCode: resp.StatusCode, Response: resp}

	case 400:
		return DecisionsPostResponse{StatusCode: resp.StatusCode, Response: resp, ErrorS: func() []Error {
			var tmp []interface{}
			json.NewDecoder(resp.Body).Decode(&tmp)
			var all []Error
			for _, el := range tmp {
				all = append(all, ErrorFromMap(el))
			}
			return all
		}()}

	default:
		return DecisionsPostResponse{StatusCode: resp.StatusCode, Response: resp, Error: errors.New(resp.Status)}
	}

}

type TransactionsPostResponse struct {
	StatusCode int
	Response   *http.Response
	Error      error
	Decision   Decision
	ErrorS     []Error
}

func TransactionsPost(client Client, transaction Transaction) TransactionsPostResponse {

	requestUrl := fmt.Sprintf("%s/transaction", client.BaseUrl)

	bodyDocument, err := json.Marshal(transaction)
	if err != nil {
		return TransactionsPostResponse{Error: err}
	}
	body := ClientRequestBody{contentType: "application/json", bytes: bytes.NewReader(bodyDocument)}

	request, err := buildRequest(client, "POST", requestUrl, body)
	if err != nil {
		return TransactionsPostResponse{Error: err}
	}

	resp, err := client.HttpClient.Do(request)
	if err != nil {
		return TransactionsPostResponse{Error: err}
	}
	defer resp.Body.Close()

	switch resp.StatusCode {
	case 200:
		return TransactionsPostResponse{StatusCode: resp.StatusCode, Response: resp, Decision: DecisionFromJson(resp.Body)}

	case 400:
		return TransactionsPostResponse{StatusCode: resp.StatusCode, Response: resp, ErrorS: func() []Error {
			var tmp []interface{}
			json.NewDecoder(resp.Body).Decode(&tmp)
			var all []Error
			for _, el := range tmp {
				all = append(all, ErrorFromMap(el))
			}
			return all
		}()}

	default:
		return TransactionsPostResponse{StatusCode: resp.StatusCode, Response: resp, Error: errors.New(resp.Status)}
	}

}

func buildRequest(client Client, method, urlStr string, body ClientRequestBody) (*http.Request, error) {

	request, err := http.NewRequest(method, urlStr, body.bytes)
	if err != nil {
		return nil, err
	}

	request.Header.Add("User-Agent",             UserAgent)
	request.Header.Add("X-Apidoc-Version",       Version)
	request.Header.Add("X-Apidoc-Version-Major", strconv.Itoa(VersionMajor))

	if client.Headers != nil {
		for key, values := range client.Headers {
			for _, value := range values {
				request.Header.Add(key, value)
			}
		}
	}

	if body.contentType != "" {
		request.Header.Add("Content-Type", body.contentType)
	}

	if client.Username != "" {
		request.SetBasicAuth(client.Username, client.Password)
	}

	return request, nil

}