package payment

import (
	"context"
	"fmt"
	"net/http"
	"time"

	"dev.tandem.ws/tandem/camper/pkg/auth"
	"dev.tandem.ws/tandem/camper/pkg/database"
	httplib "dev.tandem.ws/tandem/camper/pkg/http"
	"dev.tandem.ws/tandem/camper/pkg/locale"
	"dev.tandem.ws/tandem/camper/pkg/redsys"
	"dev.tandem.ws/tandem/camper/pkg/template"
	"dev.tandem.ws/tandem/camper/pkg/uuid"
)

type AdminHandler struct {
}

func NewAdminHandler() *AdminHandler {
	return &AdminHandler{}
}

func (h *AdminHandler) Handler(user *auth.User, company *auth.Company, conn *database.Conn) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		var head string
		head, r.URL.Path = httplib.ShiftPath(r.URL.Path)

		switch head {
		case "":
			switch r.Method {
			case http.MethodGet:
				servePaymentIndex(w, r, user, company, conn)
			default:
				httplib.MethodNotAllowed(w, r, http.MethodGet)
			}
		case "settings":
			head, r.URL.Path = httplib.ShiftPath(r.URL.Path)
			switch head {
			case "":
				switch r.Method {
				case http.MethodGet:
					f := newSettingsForm(user.Locale)
					if err := f.FillFromDatabase(r.Context(), company, conn); err != nil {
						if !database.ErrorIsNotFound(err) {
							panic(err)
						}
					}
					f.MustRender(w, r, user, company)
				case http.MethodPut:
					updatePaymentSettings(w, r, user, company, conn)
				default:
					httplib.MethodNotAllowed(w, r, http.MethodGet, http.MethodPut)
				}
			default:
				http.NotFound(w, r)
			}
		default:
			if !uuid.Valid(head) {
				http.NotFound(w, r)
				return
			}
			payment, err := fetchPaymentDetails(r.Context(), conn, head, user.Locale)
			if err != nil {
				if database.ErrorIsNotFound(err) {
					http.NotFound(w, r)
					return
				}
				panic(err)
			}
			h.paymentHandler(user, company, conn, payment).ServeHTTP(w, r)
		}
	})
}

func (h *AdminHandler) paymentHandler(user *auth.User, company *auth.Company, conn *database.Conn, payment *paymentDetails) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		var head string
		head, r.URL.Path = httplib.ShiftPath(r.URL.Path)

		switch head {
		case "":
			switch r.Method {
			case http.MethodGet:
				if payment.Status == StatusPreAuthenticated {
					var err error
					if err = conn.QueryRow(r.Context(), "select environment from redsys where company_id = $1", company.ID).Scan(&payment.Environment); err != nil && !database.ErrorIsNotFound(err) {
						panic(err)
					}
					payment.AcceptPreauthRequest, err = payment.createRequest(r, user, company, conn, redsys.TransactionTypePreauthConfirm)
					if err != nil {
						panic(err)
					}
					payment.VoidPreauthRequest, err = payment.createRequest(r, user, company, conn, redsys.TransactionTypePreauthVoid)
					if err != nil {
						panic(err)
					}
				}
				payment.MustRender(w, r, user, company)
			default:
				httplib.MethodNotAllowed(w, r, http.MethodGet)
			}
		default:
			http.NotFound(w, r)
		}
	})
}

func servePaymentIndex(w http.ResponseWriter, r *http.Request, user *auth.User, company *auth.Company, conn *database.Conn) {
	payments, err := collectPaymentEntries(r.Context(), company, conn, user.Locale)
	if err != nil {
		panic(err)
	}
	page := &paymentIndex{
		Payments: payments,
	}
	page.MustRender(w, r, user, company)
}

type paymentEntry struct {
	URL         string
	Reference   string
	DownPayment string
	Total       string
	Status      string
	StatusLabel string
	CreatedAt   time.Time
}

func collectPaymentEntries(ctx context.Context, company *auth.Company, conn *database.Conn, locale *locale.Locale) ([]*paymentEntry, error) {
	rows, err := conn.Query(ctx, `
		select '/admin/payments/' || payment.slug
		     , payment.reference
		     , to_price(payment.down_payment, decimal_digits)
		     , to_price(total, decimal_digits)
		     , payment.payment_status
		     , coalesce(payment_status_i18n.name, payment_status.name)
		     , created_at
		from payment
			join currency using (currency_code)
		    join payment_status using (payment_status)
        	left join payment_status_i18n on payment_status_i18n.payment_status = payment.payment_status
				and payment_status_i18n.lang_tag = $2
		where company_id = $1
		order by created_at desc
	`, company.ID, locale.Language)
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	var payments []*paymentEntry
	for rows.Next() {
		entry := &paymentEntry{}
		if err = rows.Scan(
			&entry.URL,
			&entry.Reference,
			&entry.DownPayment,
			&entry.Total,
			&entry.Status,
			&entry.StatusLabel,
			&entry.CreatedAt,
		); err != nil {
			return nil, err
		}
		payments = append(payments, entry)
	}

	return payments, nil
}

type paymentIndex struct {
	Payments []*paymentEntry
}

func (page *paymentIndex) MustRender(w http.ResponseWriter, r *http.Request, user *auth.User, company *auth.Company) {
	template.MustRenderAdmin(w, r, user, company, "payment/index.gohtml", page)
}

type paymentDetails struct {
	ID                   int
	Slug                 string
	Reference            string
	CampsiteType         string
	ArrivalDate          time.Time
	DepartureDate        time.Time
	NumNights            int
	NumAdults            int
	NumTeenagers         int
	NumChildren          int
	NumDogs              int
	SubtotalTouristTax   string
	Total                string
	DownPaymentPercent   int
	DownPayment          string
	ZonePreferences      string
	ACSICard             bool
	Status               string
	StatusLabel          string
	CreatedAt            time.Time
	UpdatedAt            time.Time
	Options              []*paymentOption
	Customer             *paymentCustomer
	Environment          string
	AcceptPreauthRequest *redsys.SignedRequest
	VoidPreauthRequest   *redsys.SignedRequest
}

type paymentOption struct {
	Label string
	Units int
}

type paymentCustomer struct {
	FullName   string
	Address    string
	PostalCode string
	City       string
	Country    string
	Email      string
	Phone      string
	Language   string
}

func fetchPaymentDetails(ctx context.Context, conn *database.Conn, slug string, locale *locale.Locale) (*paymentDetails, error) {
	row := conn.QueryRow(ctx, `
		select payment_id
		     , payment.slug
		     , payment.reference
		     , coalesce(campsite_type_i18n.name, campsite_type.name)
		     , arrival_date
		     , departure_date
		     , departure_date - arrival_date
		     , number_adults
		     , number_teenagers
		     , number_children
		     , number_dogs
		     , to_price(subtotal_tourist_tax, decimal_digits)
		     , to_price(total, decimal_digits)
		     , (down_payment_percent * 100)::integer
		     , to_price(payment.down_payment, decimal_digits)
		     , zone_preferences
		     , acsi_card
		     , payment.payment_status
		     , coalesce(payment_status_i18n.name, payment_status.name)
		     , created_at
		     , updated_at
		from payment
		    join currency using (currency_code)
		    join campsite_type using (campsite_type_id)
		    join payment_status using (payment_status)
        	left join payment_status_i18n on payment_status_i18n.payment_status = payment.payment_status
				and payment_status_i18n.lang_tag = $2
        	left join campsite_type_i18n on campsite_type_i18n.campsite_type_id = campsite_type.campsite_type_id
				and campsite_type_i18n.lang_tag = $2
		where payment.slug = $1
	`, slug, locale.Language)
	details := &paymentDetails{}
	if err := row.Scan(
		&details.ID,
		&details.Slug,
		&details.Reference,
		&details.CampsiteType,
		&details.ArrivalDate,
		&details.DepartureDate,
		&details.NumNights,
		&details.NumAdults,
		&details.NumTeenagers,
		&details.NumChildren,
		&details.NumDogs,
		&details.SubtotalTouristTax,
		&details.Total,
		&details.DownPaymentPercent,
		&details.DownPayment,
		&details.ZonePreferences,
		&details.ACSICard,
		&details.Status,
		&details.StatusLabel,
		&details.CreatedAt,
		&details.UpdatedAt,
	); err != nil {
		return nil, err
	}

	var err error
	details.Options, err = fetchPaymentOptions(ctx, conn, details.ID, locale)
	if err != nil && !database.ErrorIsNotFound(err) {
		return nil, err
	}

	details.Customer, err = fetchPaymentCustomer(ctx, conn, details.ID, locale)
	if err != nil && !database.ErrorIsNotFound(err) {
		return nil, err
	}

	return details, nil
}

func fetchPaymentOptions(ctx context.Context, conn *database.Conn, paymentID int, locale *locale.Locale) ([]*paymentOption, error) {
	rows, err := conn.Query(ctx, `
		select coalesce(option_i18n.name, option.name)
		     , units
		from payment_option
			join campsite_type_option as option using (campsite_type_option_id)
			left join campsite_type_option_i18n as option_i18n on option_i18n.campsite_type_option_id = option.campsite_type_option_id
				and option_i18n.lang_tag = $2
		where payment_id = $1
`, paymentID, locale.Language)
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	var options []*paymentOption
	for rows.Next() {
		option := &paymentOption{}
		if err = rows.Scan(&option.Label, &option.Units); err != nil {
			return nil, err
		}
		options = append(options, option)
	}
	return options, nil
}

func fetchPaymentCustomer(ctx context.Context, conn *database.Conn, paymentID int, locale *locale.Locale) (*paymentCustomer, error) {
	row := conn.QueryRow(ctx, `
		select full_name
		     , address
		     , postal_code
		     , city
		     , coalesce(country_i18n.name, country.name)
		     , email
		     , phone::text
		     , language.endonym
		from payment_customer
			join country using (country_code)
			left join country_i18n on country.country_code = country_i18n.country_code
				and country_i18n.lang_tag = $2
			join language on payment_customer.lang_tag = language.lang_tag
		where payment_id = $1
`, paymentID, locale.Language)
	customer := &paymentCustomer{}
	if err := row.Scan(
		&customer.FullName,
		&customer.Address,
		&customer.PostalCode,
		&customer.City,
		&customer.Country,
		&customer.Email,
		&customer.Phone,
		&customer.Language,
	); err != nil {
		return nil, err
	}
	return customer, nil
}

func (f *paymentDetails) createRequest(r *http.Request, user *auth.User, company *auth.Company, conn *database.Conn, transactionType redsys.TransactionType) (*redsys.SignedRequest, error) {
	schema := httplib.Protocol(r)
	authority := httplib.Host(r)
	paymentURL := fmt.Sprintf("%s://%s/admin/payments/%s", schema, authority, f.Slug)
	request := redsys.Request{
		TransactionType:  transactionType,
		Amount:           f.DownPayment,
		OrderNumber:      f.Reference,
		SuccessURL:       paymentURL,
		FailureURL:       paymentURL,
		NotificationURL:  fmt.Sprintf("%s/notification", publicBaseURL(r, user, f.Slug)),
		ConsumerLanguage: user.Locale.Language,
	}
	return request.Sign(r.Context(), conn, company)
}

func (f *paymentDetails) MustRender(w http.ResponseWriter, r *http.Request, user *auth.User, company *auth.Company) {
	template.MustRenderAdmin(w, r, user, company, "payment/details.gohtml", f)
}