package handlers

import (
	"amocrm_templategen_back/amo"
	"amocrm_templategen_back/dal/model"
	"amocrm_templategen_back/templategen"
	"errors"
	"fmt"
	"github.com/gorilla/schema"
	docTemp "github.com/opencontrol/doc-template"
	"golang.org/x/oauth2"
	"io/ioutil"
	"net/http"
	"net/url"
	"strconv"
	"time"
)

type RespAmoSaveToken struct {
	AccessToken  string `json:"access_token" schema:"access_token"`
	Code         string `json:"code" schema:"code"`
	ClientID     string `json:"client_id" schema:"client_id"`
	ExpiresIn    int64  `json:"expires_in" schema:"expires_in"`
	TokenType    string `json:"token_type" schema:"token_type"`
	RefreshToken string `json:"refresh_token" schema:"refresh_token"`
	State        string `json:"state" schema:"state"`
	FromWidget   string `json:"from_widget" schema:"from_widget"`
	Referer      string `json:"referer" schema:"referer"`
}

func (h *Handlers) AmoSaveToken(w http.ResponseWriter, r *http.Request) {
	var resp RespAmoSaveToken

	err := r.ParseForm()
	if err != nil {
		h.reportError(w, err, http.StatusBadRequest)
		return
	}

	err = schema.NewDecoder().Decode(&resp, r.Form)
	if err != nil {
		h.reportError(w, err, 500)
		return
	}

	if resp.AccessToken == "" && resp.Code == "" {
		err = errors.New("AmoErr: got empty token")
		h.reportError(w, err, http.StatusBadRequest)
		return
	}

	token := &oauth2.Token{
		AccessToken:  resp.AccessToken,
		RefreshToken: resp.RefreshToken,
		TokenType:    resp.TokenType,
		Expiry:       time.Now().Add(time.Duration(resp.ExpiresIn) * time.Second),
	}

	var amoClient *amo.Client
	if resp.Code != "" {
		amoClient = h.Amo.NewClient(resp.Referer, resp.Code)
		token, err = amoClient.AuthCode()
		if err != nil {
			h.reportError(w, err, 500)
			return
		}
	}

	user := getJwtUser(r)
	if user == nil {
		h.reportError(w, ErrorUnauthorized, http.StatusUnauthorized)
		return
	}

	amoAcc, err := amoClient.GetAccount()

	if err != nil {
		h.reportError(w, err, 200)
	}
	if amoAcc == nil {
		return
	} else {
		fmt.Println(amoAcc)
	}

	// Insert/Update token in DB
	_, err = h.dal.Amo.InsertOrUpdate(r.Context(), &model.Amo{
		UserID:       user.UserID,
		AccountID:    strconv.FormatInt(amoAcc.Id, 10),
		AccessToken:  token.AccessToken,
		RefreshToken: token.RefreshToken,
		Code:         resp.Code,
		FromWidget:   resp.FromWidget,
		Referer:      resp.Referer,
		Subdomain:    amoAcc.Subdomain,
		ExpiresIn:    token.Expiry,
		TokenType:    token.TokenType,
	})

	if err != nil {
		h.reportError(w, err, 500)
		return
	}

	err = sendResponse(w, 200, map[string]string{"accessToken": resp.AccessToken})
	if err != nil {
		h.reportError(w, err, 500)
	}
}

func (h *Handlers) AmoWebhook(w http.ResponseWriter, r *http.Request) {
	fmt.Println(" -------------------- AMO WEBHOOK ------------------------")
	resp := map[string]interface{}{}

	user := getJwtUser(r)
	if user != nil {
		fmt.Println("USER:", user)
	}

	err := decodePost(&resp, r)
	if err != nil {
		h.reportError(w, err, 500)
	}

	fmt.Println("RESPONSE:")
	fmt.Println(resp)

	sendResponse(w, 200, nil)
}

func (h *Handlers) AmoWebhook2(w http.ResponseWriter, r *http.Request) {
	fmt.Println(" -------------------- AMO WEBHOOK 2------------------------")
	reqBody, err := ioutil.ReadAll(r.Body)

	if err != nil {
		h.reportError(w, err, 200)
		return
	}

	p, err := url.ParseQuery(string(reqBody))
	if err != nil {
		h.reportError(w, err, 200)
		return
	}

	leadId := p.Get("leads[status][0][id]")
	subdomain := p.Get("account[subdomain]")
	accId := p.Get("account[id]")

	// Запрашиваем данные по аккаунту
	amoData, err := h.dal.Amo.GetByAccountID(r.Context(), accId)
	if err != nil {
		h.reportError(w, err, 200)
		return
	}

	amoClient := h.Amo.NewClient(subdomain+".amocrm.ru", amoData.Code)

	amoClient.SetToken(&oauth2.Token{
		AccessToken:  amoData.AccessToken,
		TokenType:    amoData.TokenType,
		RefreshToken: amoData.RefreshToken,
		Expiry:       amoData.ExpiresIn,
	})

	lead, err := amoClient.GetLeadById(leadId)
	if err != nil {
		h.reportError(w, err, 200)
		return
	}

	if lead != nil {
		// fmt.Printf("Lead RESP:%+v\r\n", lead)
	} else {
		fmt.Println("Lead empty")
	}

	dataTemplate := map[string]interface{}{}

	// Добавляем Инфо Лида
	for k, v := range templategen.AmoLeadFieldsToRuMap(lead) {
		dataTemplate[k] = v
	}

	filename := fmt.Sprintf("%v", dataTemplate["Filename"])

	// Добавялем инфо контактов
	contacts := []amo.Contact{}
	for _, data := range lead.Embedded.Contacts {
		contact, err := amoClient.GetContactById(strconv.Itoa(data.Id))
		if err == nil {
			contacts = append(contacts, *contact)
		} else {
			fmt.Println("Something Wrong1:", err)
		}
	}

	for k, v := range templategen.AmoContactsFieldsToRuMap(contacts) {
		dataTemplate[k] = v
	}

	// Добавляем инфо компаний
	companies := []amo.Company{}
	for _, data := range lead.Embedded.Companies {
		company, err := amoClient.GetCompanyById(strconv.Itoa(data.Id))
		if err == nil {
			companies = append(companies, *company)
		} else {
			fmt.Println("Something Wrong2:", err)
		}
	}

	for k, v := range templategen.AmoCompaniesFieldsToRuMap(companies) {
		dataTemplate[k] = v
	}

	//user := getJwtUser(r)
	//if user != nil {
	//	//
	//}

	fmt.Printf("dataTemplate: %+v\r\n", dataTemplate)

	user, err := h.dal.User.GetByID(r.Context(), amoData.UserID)
	if err != nil {
		h.reportError(w, err, 200)
	}

	// PARSING
	yaDiskData, err := h.dal.YaDisk.GetByUserID(r.Context(), user.ID)
	if err != nil {
		h.reportError(w, err, http.StatusInternalServerError)
		return
	}

	if yaDiskData == nil {
		h.reportError(w, errors.New("YaDisk not found"), 200)
		return
	}

	// download file
	client := h.YaDisk.NewClient(yaDiskData.AccessToken)

	res, err := client.GetResources(yaDiskData.TemplateFolder + "/" + filename)
	if res == nil {
		h.reportError(w, errors.New("resource in yandex disk not found"), http.StatusNotFound)
		return
	}
	downloadFileName := fmt.Sprintf("./tmp/downloaded/%v_%v", user.ID, filename)

	err = templategen.DownloadDocument(downloadFileName, res.File)
	if err != nil {
		h.reportError(w, err, 200)
		return
	}

	// parsing file
	dc, err := docTemp.GetTemplate(downloadFileName)
	if err != nil {
		h.reportError(w, err, 200)
		return
	}

	dc.Parse()

	saveFilename := fmt.Sprintf("%v_%v_%v", user.ID, time.Now().Unix(), filename)
	err = dc.Execute("./tmp/parsed/"+saveFilename, dataTemplate)
	if err != nil {
		h.reportError(w, err, 200)
		return
	}

	// Send to Yandex Disk

	err = client.ResourcesUpload(yaDiskData.SaveFolder+"/"+saveFilename, "https://solweb.site/tmp/parsed/"+saveFilename)
	if err != nil {
		h.reportError(w, err, 200)
		return
	}

	//err := decodePost(&resp, r)
	//if err != nil {
	//	h.reportError(w, err, 200)
	//}

	//err := r.ParseForm()
	//if err != nil {
	//	h.reportError(w, err, 200)
	//}
	//
	//err = schema.NewDecoder().Decode(&resp, r.Form)
	//if err != nil {
	//	h.reportError(w, err, 200)
	//}

	//fmt.Println("RESPONSE:", r.PostForm.Encode())
	sendResponse(w, 200, nil)
}