package model

import (
	"context"
	"database/sql"
	"fmt"
	"gen_transit_point/utils"

	"github.com/lib/pq"
	"github.com/opentracing/opentracing-go"
	"gorm.io/gorm"
	"gorm.io/gorm/schema"
)

type TransitPoint struct {
	ID                      int64   `json:"id"`
	CompanyID               int64   `json:"company_id"`
	CustomerID              int64   `json:"customer_id"`
	CustomerIDs             []int64 `json:"customer_ids"`
	TripGroupTransitPointID *int64  `json:"trip_group_transit_point_id"`
	Status                  bool    `json:"status"`
	Blacklist               bool    `json:"blacklist"`
	Latitude                float64 `json:"latitude"`
	Longitude               float64 `json:"longitude"`
	RegisterDate            string  `json:"register_date"`
	UnregisterDate          string  `json:"unregister_date"`
	CreatedDate             string  `json:"created_date"`
	ModifiedDate            string  `json:"modified_date"`
	Name                    string  `json:"name"`
	Code                    string  `json:"code"`
	Geocode                 string  `json:"geocode"`
	Address                 string  `json:"address"`
	CreatedBy               string  `json:"created_by"`
	ModifiedBy              string  `json:"modified_by"`
	PicName                 string  `json:"pic_name"`
	PicPhone                string  `json:"pic_phone"`
	PicMobile               string  `json:"pic_mobile"`
	TransitPointType        string  `json:"transit_point_type"`
	Remark                  string  `json:"remark"`
	Coords                  string  `json:"coords"`
	Fax                     string  `json:"fax"`
	MobileNo                string  `json:"mobile_no"`
	Phone                   string  `json:"phone"`
	Image                   string  `json:"image"`
	ZipCode                 string  `json:"zip_code"`
	GeomWkt                 string  `json:"geom" gorm:"column:geom" validate:"required"`
	GeomWkb                 string  `json:"geom_wkb,omitempty" gorm:"-"`
	CentroidLon             float64 `json:"centroid_lon,omitempty" gorm:"-"`
	CentroidLat             float64 `json:"centroid_lat,omitempty" gorm:"-"`
}

type TransitPointDB struct {
	ID                      sql.NullInt64   `json:"id"`
	CompanyID               sql.NullInt64   `json:"company_id"`
	CustomerID              sql.NullInt64   `json:"customer_id"`
	CustomerIDs             pq.Int64Array   `json:"customer_ids" gorm:"type:bigint[];default:'{}'::bigint[]"`
	TripGroupTransitPointID sql.NullInt64   `json:"trip_group_transit_point_id"`
	Status                  sql.NullBool    `json:"status"`
	Blacklist               sql.NullBool    `json:"blacklist"`
	Latitude                sql.NullFloat64 `json:"latitude"`
	Longitude               sql.NullFloat64 `json:"longitude"`
	RegisterDate            sql.NullTime    `json:"register_date"`
	UnregisterDate          sql.NullTime    `json:"unregister_date"`
	CreatedDate             sql.NullTime    `json:"created_date"`
	ModifiedDate            sql.NullTime    `json:"modified_date"`
	Name                    sql.NullString  `json:"name"`
	Code                    sql.NullString  `json:"code"`
	Geocode                 sql.NullString  `json:"geocode"`
	Address                 sql.NullString  `json:"address"`
	CreatedBy               sql.NullString  `json:"created_by"`
	ModifiedBy              sql.NullString  `json:"modified_by"`
	PicName                 sql.NullString  `json:"pic_name"`
	PicPhone                sql.NullString  `json:"pic_phone"`
	PicMobile               sql.NullString  `json:"pic_mobile"`
	TransitPointType        sql.NullString  `json:"transit_point_type"`
	Remark                  sql.NullString  `json:"remark"`
	Coords                  sql.NullString  `json:"coords"`
	Fax                     sql.NullString  `json:"fax"`
	MobileNo                sql.NullString  `json:"mobile_no"`
	Phone                   sql.NullString  `json:"phone"`
	Image                   sql.NullString  `json:"image"`
	ZipCode                 sql.NullString  `json:"zip_code"`
	GeomWkt                 sql.NullString  `json:"geom_wkt" gorm:"column:geom"`
	GeomWkb                 sql.NullString  `json:"geom_wkb" gorm:"-"`
	CentroidLon             sql.NullFloat64 `json:"centroid_lon" gorm:"-"`
	CentroidLat             sql.NullFloat64 `json:"centroid_lat" gorm:"-"`
}

func (t *TransitPoint) BeforeCheck(ctx context.Context) *TransitPointDB {
	checkLat := utils.ValidCoords(ctx, t.Latitude, utils.VALID_LATITUDE)
	checkLon := utils.ValidCoords(ctx, t.Longitude, utils.VALID_LONGITUDE)
	if !checkLat || !checkLon {
		lat := t.Longitude
		lon := t.Latitude
		t.Latitude = lat
		t.Longitude = lon
	}

	data := &TransitPointDB{
		ID:                      utils.NewNullInt64(ctx, &t.ID),
		CompanyID:               utils.NewNullInt64(ctx, &t.CompanyID),
		CustomerID:              utils.NewNullInt64(ctx, &t.CustomerID),
		CustomerIDs:             pq.Int64Array(t.CustomerIDs),
		TripGroupTransitPointID: utils.NewNullInt64(ctx, t.TripGroupTransitPointID),
		Status:                  utils.NewNullBool(ctx, &t.Status),
		Blacklist:               utils.NewNullBool(ctx, &t.Blacklist),
		Latitude:                utils.NewNullFloat64(ctx, &t.Latitude),
		Longitude:               utils.NewNullFloat64(ctx, &t.Longitude),
		RegisterDate:            utils.NewNullStringTime(ctx, &t.RegisterDate),
		UnregisterDate:          utils.NewNullStringTime(ctx, &t.UnregisterDate),
		CreatedDate:             utils.NewNullStringTime(ctx, &t.CreatedDate),
		ModifiedDate:            utils.NewNullStringTime(ctx, &t.ModifiedDate),
		Name:                    utils.NewNullString(ctx, &t.Name),
		Code:                    utils.NewNullString(ctx, &t.Code),
		Geocode:                 utils.NewNullString(ctx, &t.Geocode),
		Address:                 utils.NewNullString(ctx, &t.Address),
		CreatedBy:               utils.NewNullString(ctx, &t.CreatedBy),
		ModifiedBy:              utils.NewNullString(ctx, &t.ModifiedBy),
		PicName:                 utils.NewNullString(ctx, &t.PicName),
		PicPhone:                utils.NewNullString(ctx, &t.PicPhone),
		PicMobile:               utils.NewNullString(ctx, &t.PicMobile),
		TransitPointType:        utils.NewNullString(ctx, &t.TransitPointType),
		Remark:                  utils.NewNullString(ctx, &t.Remark),
		Coords:                  utils.NewNullString(ctx, &t.Coords),
		Fax:                     utils.NewNullString(ctx, &t.Fax),
		MobileNo:                utils.NewNullString(ctx, &t.MobileNo),
		Phone:                   utils.NewNullString(ctx, &t.Phone),
		Image:                   utils.NewNullString(ctx, &t.Image),
		ZipCode:                 utils.NewNullString(ctx, &t.ZipCode),
		GeomWkt:                 utils.NewNullString(ctx, &t.GeomWkt),
		GeomWkb:                 utils.NewNullString(ctx, &t.GeomWkb),
		CentroidLon:             utils.NewNullFloat64(ctx, &t.CentroidLon),
		CentroidLat:             utils.NewNullFloat64(ctx, &t.CentroidLat),
	}

	return data
}

func (t *TransitPointDB) TableName(ctx context.Context, alias ...string) func(db *gorm.DB) *gorm.DB {
	span, spanCtx := opentracing.StartSpanFromContext(ctx, "tableName")
	defer span.Finish()
	return func(db *gorm.DB) *gorm.DB {
		db = t.NamingStrategy(spanCtx, db)
		table := db.Statement.Config.NamingStrategy.TableName("transit_point")
		if len(alias) > 0 && alias[0] != "" {
			return db.Table(fmt.Sprintf("%s AS %s", table, alias[0]))
		}
		return db.Table(table)
	}
}

func (t *TransitPointDB) NamingStrategy(ctx context.Context, tx *gorm.DB) *gorm.DB {
	span, spanCtx := opentracing.StartSpanFromContext(ctx, "namingStrategy")
	defer span.Finish()
	tx.Statement.Context = spanCtx
	tx.Config.NamingStrategy = schema.NamingStrategy{
		TablePrefix:   "m_",
		SingularTable: true,
	}
	return tx
}

func (t *TransitPointDB) Convert(ctx context.Context) *TransitPoint {
	data := &TransitPoint{
		ID:                      t.ID.Int64,
		CompanyID:               t.CompanyID.Int64,
		CustomerID:              t.CustomerID.Int64,
		CustomerIDs:             []int64(t.CustomerIDs),
		TripGroupTransitPointID: &t.TripGroupTransitPointID.Int64,
		Status:                  t.Status.Bool,
		Blacklist:               t.Blacklist.Bool,
		Latitude:                t.Latitude.Float64,
		Longitude:               t.Longitude.Float64,
		RegisterDate:            utils.FormatToWithoutTZ(ctx, t.RegisterDate.Time),
		UnregisterDate:          utils.FormatToWithoutTZ(ctx, t.UnregisterDate.Time),
		CreatedDate:             utils.FormatToWithoutTZ(ctx, t.CreatedDate.Time),
		ModifiedDate:            utils.FormatToWithoutTZ(ctx, t.ModifiedDate.Time),
		Name:                    t.Name.String,
		Code:                    t.Code.String,
		Geocode:                 t.Geocode.String,
		Address:                 t.Address.String,
		CreatedBy:               t.CreatedBy.String,
		ModifiedBy:              t.ModifiedBy.String,
		PicName:                 t.PicName.String,
		PicPhone:                t.PicPhone.String,
		PicMobile:               t.PicMobile.String,
		TransitPointType:        t.TransitPointType.String,
		Remark:                  t.Remark.String,
		Coords:                  t.Coords.String,
		Fax:                     t.Fax.String,
		MobileNo:                t.MobileNo.String,
		Phone:                   t.Phone.String,
		Image:                   t.Image.String,
		ZipCode:                 t.ZipCode.String,
		//GeomWkb:                 t.GeomWkb.String,
		GeomWkt: t.GeomWkt.String,
		//CentroidLon:             t.CentroidLon.Float64,
		//CentroidLat:             t.CentroidLat.Float64,
	}
	checkLat := utils.ValidCoords(ctx, data.Latitude, utils.VALID_LATITUDE)
	checkLon := utils.ValidCoords(ctx, data.Longitude, utils.VALID_LONGITUDE)
	if !checkLat || !checkLon {
		lat := data.Longitude
		lon := data.Latitude
		data.Latitude = lat
		data.Longitude = lon
	}

	/* if data.Latitude == 0 || data.Longitude == 0 {
		data.Latitude = data.CentroidLat
		data.Longitude = data.CentroidLon
	} */

	return data
}