package queries

import (
	"fmt"

	"fiskerinc.com/modules/common"
	"fiskerinc.com/modules/db"
	"fiskerinc.com/modules/logger"
	"fiskerinc.com/modules/validator"

	"github.com/go-pg/pg/v10"
	"github.com/go-pg/pg/v10/orm"
	"github.com/pkg/errors"
)

type UpdateManifestsInterface interface {
	QueryBaseInterface
	Archive(ids []int64, active bool) (orm.Result, error)
	Count(filter common.UpdateManifest) (int, error)
	Delete(manifest *common.UpdateManifest) (orm.Result, error)
	Insert(manifest *common.UpdateManifest) (orm.Result, error)
	Select(filter *common.UpdateManifest, paging *PageQueryOptions) ([]common.UpdateManifest, error)
	SelectByVIN(vin string, paging *PageQueryOptions) ([]common.StatusManifest, error)
	Update(manifest *common.UpdateManifest) (orm.Result, error)
	Load(manifest *common.UpdateManifest) error
	Search(filter common.UpdateManifestSearch, paging *PageQueryOptions) ([]common.UpdateManifest, error)
	SearchCount(filter common.UpdateManifestSearch) (int, error)
	ECURollback(man *common.UpdateManifestECU, vin string) ([]*common.UpdateManifestECU, error)
	ECUInsert(manifest *common.UpdateManifestECU) (orm.Result, error)
	FileInsert(manifest *common.UpdateManifestFile) (orm.Result, error)
	AddSUMSVersion(manifest *common.UpdateManifest) (orm.Result, error)
	SelectFlashPackByVersion(versionNumber string) (manifest common.UpdateManifest, err error)
}

// NewUpdateManifest returns UpdateManifestInterface.
// mode allows to use more flexible requests.
// If mode is nil, default mode is used.
func NewUpdateManifest(mode UpdateManifestMode) UpdateManifestsInterface {
	if mode == nil {
		return &UpdateManifests{
			mode: DefaultMode{},
		}
	}

	return &UpdateManifests{
		mode: mode,
	}
}

type UpdateManifests struct {
	mode UpdateManifestMode
	QueryBase
}

func (um *UpdateManifests) Count(filter common.UpdateManifest) (int, error) {
	query := um.GetDBConn().Model((*common.UpdateManifest)(nil))

	um.selectFilter(query, &filter)

	return query.Count()
}

func (um *UpdateManifests) Delete(manifest *common.UpdateManifest) (orm.Result, error) {
	total := ORMResults{}

	err := validator.ValidateIDField(manifest.ID)
	if err != nil {
		return nil, err
	}

	err = um.Load(manifest)
	if err != nil {
		return nil, err
	}

	tx, err := um.GetDBConn().Begin()
	if err != nil {
		return nil, err
	}

	_, err = um.manifestDelete(tx, &total, manifest)
	if err != nil {
		tx.Rollback()
		return nil, err
	}

	err = tx.Commit()
	if err != nil {
		return nil, err
	}

	return &total, err
}

func (um *UpdateManifests) Insert(manifest *common.UpdateManifest) (orm.Result, error) {
	total := ORMResults{}

	tx, err := um.GetDBConn().Begin()
	if err != nil {
		err = errors.WithStack(err)
		return nil, err
	}

	_, err = um.manifestInsert(tx, &total, manifest)
	if err != nil {
		tx.Rollback()
		err = errors.WithStack(err)
		return nil, err
	}

	err = tx.Commit()
	if err != nil {
		err = errors.WithStack(err)
		return nil, err
	}

	return &total, nil
}

func (um *UpdateManifests) ECUInsert(ecu *common.UpdateManifestECU) (orm.Result, error) {
	total := ORMResults{}

	tx, err := um.GetDBConn().Begin()
	if err != nil {
		return nil, err
	}

	_, err = um.ecuInsert(tx, &total, ecu)
	if err != nil {
		tx.Rollback()
		return nil, err
	}

	err = tx.Commit()
	if err != nil {
		return nil, err
	}

	return &total, nil
}

func (um *UpdateManifests) FileInsert(file *common.UpdateManifestFile) (orm.Result, error) {
	total := ORMResults{}

	tx, err := um.GetDBConn().Begin()
	if err != nil {
		return nil, err
	}

	_, err = um.fileInsert(tx, &total, file)
	if err != nil {
		tx.Rollback()
		return nil, err
	}

	err = tx.Commit()
	if err != nil {
		return nil, err
	}

	return &total, nil
}

func (um *UpdateManifests) Select(filter *common.UpdateManifest, paging *PageQueryOptions) ([]common.UpdateManifest, error) {
	manifests := []common.UpdateManifest{}
	query := um.GetDBConn().Model(&manifests)

	um.selectFilter(query, filter)
	um.pageQuery(query, paging)

	err := query.Select()

	return manifests, errors.WithStack(err)
}

func (um *UpdateManifests) Archive(ids []int64, active bool) (orm.Result, error) {
	manifests := []common.UpdateManifest{}
	return um.resultWithStack(
		um.GetDBConn().Model(&manifests).
			Set("active = ?", active).
			Where("id IN (?)", pg.In(ids)).
			Update(),
	)
}

func (um *UpdateManifests) SelectByVIN(vin string, paging *PageQueryOptions) ([]common.StatusManifest, error) {
	manifests := []common.StatusManifest{}
	query := um.GetDBConn().Model(&manifests)
	query.
		ColumnExpr("status_manifest.*").
		ColumnExpr("car_updates.status as status").
		ColumnExpr("car_updates.updated_at as status_updated").
		ColumnExpr("status_manifest.created_at as manifest_created").
		Join("LEFT JOIN car_updates ON car_updates.update_manifest_id=status_manifest.id").
		Where("vin = ?", vin)

	query = um.mode.SelectByVINCondition(query)
	query = um.pageQuery(query, paging)
	err := query.Select()

	return manifests, errors.WithStack(err)
}

func (um *UpdateManifests) Update(manifest *common.UpdateManifest) (orm.Result, error) {
	err := validator.ValidateIDField(manifest.ID)
	if err != nil {
		return nil, err
	}
	query := um.GetDBConn().Model(manifest).Column(
		"name",
		"release_notes",
		"type",
		"fingerprint",
		"rollback_enabled",
		"update_duration",
		"max_attempts",
	)
	if manifest.Active != nil {
		query = query.Column("active")
	}
	if manifest.Env != "" {
		query = query.Column("env")
	}
	if manifest.SUMS != "" {
		query = query.Column("sums")
	}

	return query.WherePK().Update()
}

func (um *UpdateManifests) Load(manifest *common.UpdateManifest) error {
	query := um.GetDBConn().Model(manifest)

	if manifest.ID > 0 {
		query.WherePK()
	} else if manifest.Name != "" && manifest.Version != "" {
		query.Where("name = ?name AND version = ?version")
	} else {
		return errors.New("no id, name or version")
	}

	// For Magna, we will add the manifest type, then we will only get it when it is equal to two
	if manifest.ManifestType > 0 {
		query.Where("manifest_type = ?", manifest.ManifestType)
	}

	if manifest.Env == "" {
		manifest.Env = common.EnvCurrent
	}

	return um.mode.LoadRelations(query)
}

func (um *UpdateManifests) Search(filter common.UpdateManifestSearch, paging *PageQueryOptions) ([]common.UpdateManifest, error) {
	manifests := []common.UpdateManifest{}
	query := um.GetDBConn().Model(&manifests)

	um.searchFilter(query, &filter)
	um.pageQuery(query, paging)

	err := query.Select()

	return manifests, errors.WithStack(err)
}

func (um *UpdateManifests) SearchCount(filter common.UpdateManifestSearch) (int, error) {
	query := um.GetDBConn().Model((*common.UpdateManifest)(nil))

	um.searchFilter(query, &filter)

	return query.Count()
}

// Used to get rollbacks for ecu's
func (um *UpdateManifests) ECURollback(man *common.UpdateManifestECU, vin string) (rollBackManifest []*common.UpdateManifestECU, err error) {
	// Use our new rollback system, if it fails return the old get for rollbacks
	// This may fail as the car_ecus system is a bit corrupted in data
	targetedRollback, err := um.getECURollbackSpecificToCar(man, vin)
	if err == nil && targetedRollback != nil {
		rollBackManifest = append(rollBackManifest, targetedRollback)
		return
	}

	return um.getRollbacksListOfPossible(man)
}

func (um *UpdateManifests) getECURollbackSpecificToCar(man *common.UpdateManifestECU, vin string) (rollbackManifest *common.UpdateManifestECU, err error) {
	conn := um.GetDBConn()
	targetCarECU := common.CarECU{}
	targetCarECU.VIN = vin
	targetCarECU.ECU = man.ECU
	// Using the ecu and vin, get the latest carECU for that specific car
	err = conn.Model(&targetCarECU).
		Where("vin = ?", targetCarECU.VIN).
		Where("ecu = ?", targetCarECU.ECU).
		Where("version != 'unavailable'"). // We have so many of these though, like its not something that you can even roll back to
		Order("epoch_usec DESC").
		Limit(1).
		Select()

	if err != nil {
		logger.Warn().Err(err).Msgf("failed to get car ecu for rollback for car %s  ecu %s", vin, man.ECU)
		return
	}

	if targetCarECU.Version == "" {
		logger.Warn().Interface("target car ecu", targetCarECU).Msgf("failed to fetch a previous ecu version for car %s ecu %s", vin, man.ECU)
		err = fmt.Errorf("getRollBackNew error")
		return
	}

	targetManifest := common.UpdateManifestECU{}
	err = conn.Model(&targetManifest).
		Where("version = ?", targetCarECU.Version).
		Where("ecu = ?", targetCarECU.ECU).
		Select()
	if err != nil {
		logger.Warn().Err(err).Msgf("failed to get ecu rollback update manifest ecu for car %s", vin)
		return
	}
	if targetManifest.ID == 0 {
		logger.Warn().Interface("target ecu", targetCarECU).Msgf("failed to get ecu rollback update manifest ecu for car %s", vin)
		err = fmt.Errorf("getRollBackNew error")
		return
	}
	return
}

func (um *UpdateManifests) getRollbacksListOfPossible(man *common.UpdateManifestECU) (rollBackManifest []*common.UpdateManifestECU, err error) {
	var manifests []*common.UpdateManifestECU
	conn := um.GetDBConn()
	sub := conn.Model(&manifests).ColumnExpr("version, max(created_at)").
		Where("ecu = ?", man.ECU).
		Where("hw_versions = ?", pg.Array(man.HWVersions)).
		Where("version != ?", man.Version).
		Group("version")
	err = conn.
		Model(&manifests).
		With("sub", sub).
		Column("update_manifest_ecu.version", "id").
		Join("INNER JOIN sub ON update_manifest_ecu.version = sub.version AND "+
			"update_manifest_ecu.created_at = sub.max").
		Where("ecu = ?", man.ECU).
		Where("hw_versions = ?", pg.Array(man.HWVersions)).
		Where("update_manifest_ecu.version != ?", man.Version).
		Relation("Files").
		Relation("Files.WriteRegion").
		Relation("Files.EraseRegion").
		Order("version").
		Select()
	if err != nil {
		errors.WithMessagef(err, "failed to do ECURollback() for manifest_id %d on ECU %s id: %d", man.UpdateManifestID, man.ECU, man.ID)
		return nil, err
	}

	return
}

func (um *UpdateManifests) manifestDelete(operation db.Operation, resultsTotal *ORMResults, manifest *common.UpdateManifest) (orm.Result, error) {
	// Removed manifest.ecuDelete as the deletes are now propagated by the database
	result, err := um.resultWithStack(operation.Model(manifest).WherePK().Delete())
	if um.hasErrorResult(resultsTotal, result, err) {
		return nil, err
	}

	return resultsTotal, nil
}

func (um *UpdateManifests) manifestInsert(operation db.Operation, resultsTotal *ORMResults, manifest *common.UpdateManifest) (orm.Result, error) {
	result, err := um.resultWithStack(operation.Model(manifest).Insert())
	if um.hasErrorResult(resultsTotal, result, err) {
		return nil, err
	}
	resultsTotal.SetModel(result.Model())

	if manifest.ECUs != nil {
		for i := range manifest.ECUs {
			ecu := manifest.ECUs[i]
			ecu.UpdateManifestID = manifest.ID
			result, err = um.ecuInsert(operation, resultsTotal, ecu)
			if um.hasErrorResult(resultsTotal, result, err) {
				return nil, err
			}
		}
	}

	return resultsTotal, nil
}

func (um *UpdateManifests) ecuDelete(operation db.Operation, resultsTotal *ORMResults, ecu *common.UpdateManifestECU) (orm.Result, error) {
	if ecu.Files != nil {
		for i := range ecu.Files {
			file := ecu.Files[i]
			result, err := um.fileDelete(operation, resultsTotal, file)
			if um.hasErrorResult(resultsTotal, result, err) {
				return nil, err
			}
		}
	}

	result, err := operation.Model(ecu).WherePK().Delete()
	if um.hasErrorResult(resultsTotal, result, err) {
		return nil, err
	}

	return resultsTotal, nil
}

func (um *UpdateManifests) ecuInsert(operation db.Operation, resultsTotal *ORMResults, ecu *common.UpdateManifestECU) (orm.Result, error) {
	result, err := um.resultWithStack(operation.Model(ecu).Insert())
	if um.hasErrorResult(resultsTotal, result, err) {
		return nil, err
	}

	if ecu.Files != nil {
		for i := range ecu.Files {
			file := ecu.Files[i]
			file.UpdateManifestECUID = ecu.ID
			result, err := um.fileInsert(operation, resultsTotal, file)
			if um.hasErrorResult(resultsTotal, result, err) {
				return nil, err
			}
		}
	}

	return resultsTotal, nil
}

func (um *UpdateManifests) fileDelete(operation db.Operation, resultsTotal *ORMResults, file *common.UpdateManifestFile) (orm.Result, error) {
	result, err := um.resultWithStack(operation.Model(file).WherePK().Delete())
	if um.hasErrorResult(resultsTotal, result, err) {
		return nil, err
	}
	resultsTotal.SetModel(result.Model())

	result, err = um.resultWithStack(operation.Model(&common.MemoryRegion{ID: file.WriteRegionID}).WherePK().Delete())
	if um.hasErrorResult(resultsTotal, result, err) {
		return nil, err
	}

	if file.EraseRegionID != 0 {
		result, err = um.resultWithStack(operation.Model(&common.MemoryRegion{ID: file.EraseRegionID}).WherePK().Delete())
		if um.hasErrorResult(resultsTotal, result, err) {
			return nil, err
		}
	}

	result, err = um.fileKeyDelete(operation, resultsTotal, file)
	if um.hasErrorResult(resultsTotal, result, err) {
		return nil, err
	}

	return resultsTotal, nil
}

func (um *UpdateManifests) fileKeyDelete(operation db.Operation, resultsTotal *ORMResults, file *common.UpdateManifestFile) (orm.Result, error) {
	fk := &common.FileKey{FileID: file.FileID}
	result, err := um.resultWithStack(operation.Model(fk).WherePK().Delete())
	if um.hasErrorResult(resultsTotal, result, err) {
		return nil, err
	}
	return resultsTotal, err
}

func (um *UpdateManifests) fileInsert(operation db.Operation, resultsTotal *ORMResults, file *common.UpdateManifestFile) (orm.Result, error) {
	result, err := um.resultWithStack(operation.Model(&file.WriteRegion).Insert())
	if um.hasErrorResult(resultsTotal, result, err) {
		return nil, err
	}
	file.WriteRegionID = file.WriteRegion.ID

	if file.EraseRegion != nil {
		result, err = um.resultWithStack(operation.Model(file.EraseRegion).Insert())
		if um.hasErrorResult(resultsTotal, result, err) {
			return nil, err
		}
		file.EraseRegionID = file.EraseRegion.ID
	}

	result, err = um.resultWithStack(operation.Model(file).Insert())
	if um.hasErrorResult(resultsTotal, result, err) {
		return nil, err
	}
	resultsTotal.SetModel(result.Model())

	return resultsTotal, nil
}

func (um *UpdateManifests) selectFilter(query *orm.Query, filter *common.UpdateManifest) {
	if filter.ID > 0 {
		query.Where("id = ?", filter.ID)
	}

	if filter.Name != "" {
		query.Where("name = ?", filter.Name)
	}

	if filter.Version != "" {
		query.Where("version = ?", filter.Version)
	}

	if filter.Description != "" {
		query.Where("description LIKE ?", filter.Description)
	}

	if filter.ManifestType > 0 {
		query.Where("manifest_type = ?", filter.ManifestType)
	}

	if filter.Active != nil {
		query.Where("active = ?", filter.Active)
	}

	if filter.Country != "" {
		query.Where("country = ? or country is null", filter.Country)
	}

	if filter.PowerTrain != "" {
		query.Where("powertrain = ? or powertrain is null", filter.PowerTrain)
	}

	if filter.Restraint != "" {
		query.Where("restraint = ? or restraint is null", filter.Restraint)
	}

	if filter.Model != "" {
		query.Where("model = ? or model is null", filter.Model)
	}

	if filter.Trim != "" {
		query.Where("trim = ? or trim is null", filter.Trim)
	}

	if filter.Year != 0 {
		query.Where("year = ? or year is null", filter.Year)
	}

	if filter.BodyType != "" {
		query.Where("body_type = ? or body_type is null", filter.BodyType)
	}
}

func (um *UpdateManifests) searchFilter(query *orm.Query, filter *common.UpdateManifestSearch) {
	if filter.Search != "" {
		query.Where("document @@ plainto_tsquery(?)", filter.Search)
	}

	if filter.ManifestType == common.SoftwareUpdateType {
		filter.ManifestType = 0
		query.WhereInMulti("manifest_type in (?)", common.SoftwareUpdateType, common.MagnaManifestUpdateType, common.AftersalesUpdateType)
	}

	um.selectFilter(query, &filter.UpdateManifest)
}

func (um *UpdateManifests) AddSUMSVersion(manifest *common.UpdateManifest) (orm.Result, error) {
	return um.resultWithStack(um.GetDBConn().Model(manifest).Column("sums").Where("id = ?id AND sums IS NULL").Update())
}

// Given a flashpack version number: 14.4, we will return the corresponding flashpack
func (um *UpdateManifests) SelectFlashPackByVersion(versionNumber string) (manifest common.UpdateManifest, err error) {
	// Prepare for Like Statement
	versionNumber = "%" + versionNumber
	err = um.GetDBConn().Model(&manifest).Where("manifest_type = ? AND name LIKE ?", common.AsBuiltUpdateType, versionNumber).Limit(1).Select()
	return
}