package boot

import (
	Builder "cf-experian/module_server/handlers/Modules/Builder"
	Encryption "cf-experian/module_server/handlers/Modules/Encryption"
	Uploader "cf-experian/module_server/handlers/Modules/Uploader"
	Parser "cf-experian/module_server/handlers/Parser"
	Schema "cf-experian/module_server/handlers/Schema"
	server_handlers "cf-server/server/handlers"
	"context"
	"encoding/json"
	"encoding/xml"
	"fmt"
	"io/ioutil"
	"net/http"
	"os"
	"strings"
	"time"

	log "github.com/rs/zerolog/log"

	"github.com/aws/aws-lambda-go/events"
)

const (
	URL = `https://connect.experian.in:443/nextgen-ind-pds-webservices-cbv2/endpoint` //https://connectuat.experian.in/nextgen-ind-pds-webservices-cbv2/endpoint
)

type responseBody struct {
	Status  string `json:"status"`
	Message string `json:"message"`
}

type Identification struct {
	User     string `xml:"XMLUser"`
	Password string `xml:"XMLPassword"`
}

type Application struct {
	FTReferenceNumber   string `xml:"FTReferenceNumber"`
	CustomerReferenceID string `xml:"CustomerReferenceID"`
	EnquiryReason       int    `xml:"EnquiryReason"`
	FinancePurpose      int    `xml:"FinancePurpose"`
	AmountFinanced      int    `xml:"AmountFinanced"`
	DurationOfAgreement int    `xml:"DurationOfAgreement"`
	ScoreFlag           int    `xml:"ScoreFlag"`
	PSVFlag             string `xml:"PSVFlag"`
}

type Applicant struct {
	Surname                     string `xml:"Surname"`
	FirstName                   string `xml:"FirstName"`
	MiddleName1                 string `xml:"MiddleName1"`
	MiddleName2                 string `xml:"MiddleName2"`
	MiddleName3                 string `xml:"MiddleName3"`
	GenderCode                  int    `xml:"GenderCode"`
	IncomeTaxPAN                string `xml:"IncomeTaxPAN"`
	PANIssueDate                string `xml:"PANIssueDate"`
	PANExpirationDate           string `xml:"PANExpirationDate"`
	PassportNumber              string `xml:"PassportNumber"`
	PassportIssueDate           string `xml:"PassportIssueDate"`
	PassportExpirationDate      string `xml:"PassportExpirationDate"`
	VoterIdentityCard           string `xml:"VoterIdentityCard"`
	VoterIDIssueDate            string `xml:"VoterIDIssueDate"`
	VoterIDExpirationDate       string `xml:"VoterIDExpirationDate"`
	DriverLicenseNumber         string `xml:"DriverLicenseNumber"`
	DriverLicenseIssueDate      string `xml:"DriverLicenseIssueDate"`
	DriverLicenseExpirationDate string `xml:"DriverLicenseExpirationDate"`
	RationCardNumber            string `xml:"RationCardNumber"`
	RationCardIssueDate         string `xml:"RationCardIssueDate"`
	RationCardExpirationDate    string `xml:"RationCardExpirationDate"`
	UniversalIDNumber           string `xml:"UniversalIDNumber"`
	UniversalIDIssueDate        string `xml:"UniversalIDIssueDate"`
	UniversalIDExpirationDate   string `xml:"UniversalIDExpirationDate"`
	DateOfBirth                 string `xml:"DateOfBirth"`
	STDPhoneNumber              string `xml:"STDPhoneNumber"`
	PhoneNumber                 int    `xml:"PhoneNumber"`
	TelephoneExtension          string `xml:"TelephoneExtension"`
	TelephoneType               string `xml:"TelephoneType"`
	MobilePhone                 int    `xml:"MobilePhone"`
	EMailId                     string `xml:"EMailId"`
}

type Details struct {
	Income                      string `xml:"Income"`
	MaritalStatus               string `xml:"MaritalStatus"`
	EmployStatus                string `xml:"EmployStatus"`
	TimeWithEmploy              string `xml:"TimeWithEmploy"`
	NumberOfMajorCreditCardHeld string `xml:"NumberOfMajorCreditCardHeld"`
}

type Address struct {
	FlatNoPlotNoHouseNo    string `xml:"FlatNoPlotNoHouseNo"`
	BldgNoSocietyName      string `xml:"BldgNoSocietyName"`
	RoadNoNameAreaLocality string `xml:"RoadNoNameAreaLocality"`
	City                   string `xml:"City"`
	Landmark               string `xml:"Landmark"`
	State                  string `xml:"State"`
	PinCode                int    `xml:"PinCode"`
}

type AdditionalAddressFlag struct {
	Flag string `xml:"Flag"`
}

var payload Schema.Request

func initConfig() {
	os.Setenv("User", Encryption.Get(os.Getenv("E_USER")))
	os.Setenv("Pass", Encryption.Get(os.Getenv("E_PASS")))
}

func getIdentification() (identification Identification) {
	identificationBucket := Identification{User: os.Getenv("User"),
		Password: os.Getenv("Pass"),
	}
	return identificationBucket
}

func getApplication() (application Application) {
	applicationBucket := Application{FTReferenceNumber: "",
		CustomerReferenceID: "",
		EnquiryReason:       11, //13,
		FinancePurpose:      35, //40,
		AmountFinanced:      payload.Amount,
		DurationOfAgreement: 0,
		ScoreFlag:           1,
		PSVFlag:             "",
	}
	return applicationBucket
}

func getApplicant() (applicant Applicant) {
	applicantBucket := Applicant{Surname: payload.LastName,
		FirstName:                   payload.FirstName,
		MiddleName1:                 "",
		MiddleName2:                 "",
		MiddleName3:                 "",
		GenderCode:                  payload.Gender,
		IncomeTaxPAN:                payload.PAN,
		PANIssueDate:                "",
		PANExpirationDate:           "",
		PassportNumber:              "",
		PassportIssueDate:           "",
		PassportExpirationDate:      "",
		VoterIdentityCard:           "",
		VoterIDIssueDate:            "",
		VoterIDExpirationDate:       "",
		DriverLicenseNumber:         "",
		DriverLicenseIssueDate:      "",
		DriverLicenseExpirationDate: "",
		RationCardNumber:            "",
		RationCardIssueDate:         "",
		RationCardExpirationDate:    "",
		UniversalIDNumber:           "",
		UniversalIDIssueDate:        "",
		UniversalIDExpirationDate:   "",
		DateOfBirth:                 payload.DOB,
		STDPhoneNumber:              "",
		PhoneNumber:                 payload.Mobile,
		TelephoneExtension:          "",
		TelephoneType:               "",
		MobilePhone:                 payload.Mobile,
		EMailId:                     "",
	}
	return applicantBucket
}

func getDetails() (details Details) {
	detailsBucket := Details{Income: "",
		MaritalStatus:               "",
		EmployStatus:                "",
		TimeWithEmploy:              "",
		NumberOfMajorCreditCardHeld: "",
	}
	return detailsBucket
}

func getAddress() (address Address) {
	addressBucket := Address{FlatNoPlotNoHouseNo: payload.Address,
		BldgNoSocietyName:      "",
		RoadNoNameAreaLocality: "",
		City:                   payload.City,
		Landmark:               "",
		State:                  payload.State,
		PinCode:                payload.PinCode,
	}
	return addressBucket
}

func getAdditionalAddressFlag() (additionalAddressFlag AdditionalAddressFlag) {
	additionalAddressFlagBucket := AdditionalAddressFlag{Flag: "N"}
	return additionalAddressFlagBucket
}

func initiateExperian(request string) string {

	fmt.Print("initiateExperian")
	resp, err := http.Post(URL, "text/xml", strings.NewReader(request))

	if err != nil {
		fmt.Print(err.Error())
	}
	defer resp.Body.Close()

	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		log.Fatalln(err)
	}
	sb := string(body)

	sb = strings.Replace(sb, "&lt;", "<", -1)
	sb = strings.Replace(sb, "&gt;", ">", -1)

	//Log Response
	fileName := fmt.Sprint(payload.ResPath)
	message := Uploader.Upload(sb, fileName)
	log.Print(message)
	/* _ = ioutil.WriteFile(fileName, []byte(sb), 0644) */
	//End
	fmt.Print("initiateExperian saved")
	return sb

}

func buildRequestXML() (Head string) {

	fmt.Print("XML buildRequestXML")

	identification, _ := xml.MarshalIndent(getIdentification(), "", " ")
	application, _ := xml.MarshalIndent(getApplication(), "", " ")
	applicant, _ := xml.MarshalIndent(getApplicant(), "", " ")
	details, _ := xml.MarshalIndent(getDetails(), "", " ")
	address, _ := xml.MarshalIndent(getAddress(), "", " ")
	additionalAddressFlag, _ := xml.MarshalIndent(getAdditionalAddressFlag(), "", " ")

	request := `<?xml version="1.0" encoding="utf-8"?><soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:urn="urn:cbv2">` + "\n" + `<soapenv:Header/>` + "\n" + `<soapenv:Body>` + "\n" + `<urn:process>` + "\n" + `<urn:in>` + "\n" + `<INProfileRequest>` +
		string(identification) + "\n" +
		string(application) + "\n" +
		string(applicant) + "\n" +
		string(details) + "\n" +
		string(address) + "\n" +
		string(additionalAddressFlag) + "\n" +
		`</INProfileRequest>` + "\n" + `</urn:in>` + "\n" + `</urn:process>` + "\n" + `</soapenv:Body>` + "\n" + `</soapenv:Envelope>`

	//Log Request
	log.Print("Request Log : Calling uploader")

	fileName := fmt.Sprint(payload.ReqPath)
	message := Uploader.Upload(request, fileName)
	log.Print(message)
	/* _ = ioutil.WriteFile(fileName, []byte(request), 0644) */
	//End
	fmt.Print("XML buildRequestXML saved")
	return request
}

func boot(ctx context.Context, request events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) {
	fmt.Print("XML Preparation")
	ApiResponse := events.APIGatewayProxyResponse{}
	errorResponse := Builder.ErrorResponse{Status: "FAIL", Message: "Invalid request received"}

	initConfig()

	loc, _ := time.LoadLocation("Asia/Kolkata")
	now := time.Now().In(loc)
	timestamp := now.Unix()

	errCheck := json.Unmarshal([]byte(request.Body), &payload)
	if errCheck != nil {
		log.Fatalln(errCheck)
	}

	var segment string = ""
	if payload.RequestType == "merchant" {
		segment = "/merchant"
	}

	payload.RequestTime = timestamp
	if payload.ApplicantType == 2 {
		payload.ResPath = fmt.Sprint(segment, "/", payload.ID, "/", payload.ID, "_response", "_", payload.ApplicantType, "_experian.xml")
		payload.ReqPath = fmt.Sprint(segment, "/", payload.ID, "/", payload.ID, "_request", "_", payload.ApplicantType, "_experian.xml")
	} else {
		if payload.RequestType == "merchant" {
			payload.ResPath = fmt.Sprint(segment, "/", payload.ID, "/", payload.ID, "_response_merchant", "_experian.xml")
			payload.ReqPath = fmt.Sprint(segment, "/", payload.ID, "/", payload.ID, "_request_merchant", "_experian.xml")
		} else {
			payload.ResPath = fmt.Sprint(segment, "/", payload.ID, "/", payload.ID, "_response", "_experian.xml")
			payload.ReqPath = fmt.Sprint(segment, "/", payload.ID, "/", payload.ID, "_request", "_experian.xml")
		}
	}

	requestString := buildRequestXML()

	sbString := initiateExperian(requestString)

	res, err := Parser.RunParser(payload, sbString)

	if err != nil {
		log.Print("Boot: parser error response")
		log.Error().Err(err).Msg(err.Error())
		errorResponse.Message = err.Error()
		bytes, _ := json.Marshal(errorResponse)
		ApiResponse = events.APIGatewayProxyResponse{Body: string(bytes), StatusCode: 400}
		return ApiResponse, nil
	}

	ApiResponse = events.APIGatewayProxyResponse{Body: string(res), StatusCode: 200}
	return ApiResponse, nil
}

func ExperianHandler() http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		//vars := mux.Vars(r)
		//dummyVar := vars["project"]

		fmt.Print("XML Preparation")
		w.Header().Set("Content-Type", "application/json")

		initConfig()

		loc, _ := time.LoadLocation("Asia/Kolkata")
		now := time.Now().In(loc)
		timestamp := now.Unix()

		request, _ := ioutil.ReadAll(r.Body)
		errCheck := json.Unmarshal(request, &payload)
		if errCheck != nil {
			log.Fatalln(errCheck)
		}

		var segment string = ""
		if payload.RequestType == "merchant" {
			segment = "/merchant"
		}

		payload.RequestTime = timestamp
		if payload.ApplicantType == 2 {
			payload.ResPath = fmt.Sprint(segment, "/", payload.ID, "/", payload.ID, "_response", "_", payload.ApplicantType, "_experian.xml")
			payload.ReqPath = fmt.Sprint(segment, "/", payload.ID, "/", payload.ID, "_request", "_", payload.ApplicantType, "_experian.xml")
		} else {
			if payload.RequestType == "merchant" {
				payload.ResPath = fmt.Sprint(segment, "/", payload.ID, "/", payload.ID, "_response_merchant", "_experian.xml")
				payload.ReqPath = fmt.Sprint(segment, "/", payload.ID, "/", payload.ID, "_request_merchant", "_experian.xml")
			} else {
				payload.ResPath = fmt.Sprint(segment, "/", payload.ID, "/", payload.ID, "_response", "_experian.xml")
				payload.ReqPath = fmt.Sprint(segment, "/", payload.ID, "/", payload.ID, "_request", "_experian.xml")
			}
		}

		requestString := buildRequestXML()

		sbString := initiateExperian(requestString)

		res, err := Parser.RunParser(payload, sbString)

		if err != nil {
			log.Error().Err(err).Msg(err.Error())
			server_handlers.FormatResponse(w, 400)
			_ = json.NewEncoder(w).Encode(responseBody{Status: "FAIL", Message: err.Error()})
			return
		}

		server_handlers.FormatResponse(w, 200)
		_ = json.NewEncoder(w).Encode(res)

	}
}

/* func Start(ctx context.Context, request events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error){
    return boot(ctx, request)
} */