// This is Free Software under GNU Affero General Public License v >= 3.0
// without warranty, see README.md and license for details.
//
// SPDX-License-Identifier: AGPL-3.0-or-later
// License-Filename: LICENSES/AGPL-3.0.txt
//
// Copyright (C) 2018 by via donau
//   – Österreichische Wasserstraßen-Gesellschaft mbH
// Software engineering by Intevation GmbH
//
// Author(s):
//  * Sascha L. Teichmann <sascha.teichmann@intevation.de>
//  * Raimund Renkert <raimund.renkert@intevation.de>

package controllers

import (
	"database/sql"
	"log"
	"net/http"
	"time"

	"gemma.intevation.de/gemma/pkg/auth"
	"gemma.intevation.de/gemma/pkg/common"
	"gemma.intevation.de/gemma/pkg/imports"
	"gemma.intevation.de/gemma/pkg/models"
)

func importBottleneck(input interface{}) interface{} {
	bi := input.(*models.BottleneckImport)
	return &imports.Bottleneck{
		URL:      bi.URL,
		Insecure: bi.Insecure,
	}
}

func importGaugeMeasurement(input interface{}) interface{} {
	gi := input.(*models.GaugeMeasurementImport)
	return &imports.GaugeMeasurement{
		URL:      gi.URL,
		Insecure: gi.Insecure,
	}
}

func importFairwayAvailability(input interface{}) interface{} {
	fai := input.(*models.FairwayAvailabilityImport)
	return &imports.FairwayAvailability{
		URL:      fai.URL,
		Insecure: fai.Insecure,
	}
}

func importWaterwayAxis(input interface{}) interface{} {
	wxi := input.(*models.WaterwayAxisImport)
	return &imports.WaterwayAxis{
		URL:         wxi.URL,
		FeatureType: wxi.FeatureType,
		SortBy:      wxi.SortBy,
	}
}

func importWaterwayArea(input interface{}) interface{} {
	wai := input.(*models.WaterwayAreaImport)
	return &imports.WaterwayArea{
		URL:         wai.URL,
		FeatureType: wai.FeatureType,
		SortBy:      wai.SortBy,
	}
}

func importWaterwayGauge(input interface{}) interface{} {
	wgi := input.(*models.WaterwayGaugeImport)
	return &imports.WaterwayGauge{
		Username: nilString(wgi.User),
		Password: nilString(wgi.Password),
		Insecure: wgi.Insecure,
	}
}

func importDistancemarksVirtual(input interface{}) interface{} {
	dmvi := input.(*models.DistanceMarksVirtualImport)
	return &imports.DistanceMarksVirtual{
		URL:      dmvi.URL,
		Username: nilString(dmvi.User),
		Password: nilString(dmvi.Password),
		Insecure: dmvi.Insecure,
	}
}

func importFairwayDimension(input interface{}) interface{} {
	fdi := input.(*models.FairwayDimensionImport)
	return &imports.FairwayDimension{
		URL:                fdi.URL,
		FeatureType:        fdi.FeatureType,
		SortBy:             fdi.SortBy,
		LOS:                fdi.LOS,
		MinWidth:           fdi.MinWidth,
		MaxWidth:           fdi.MaxWidth,
		Depth:              fdi.Depth,
		SourceOrganization: fdi.SourceOrganization,
	}
}

func importDistanceMarksAshore(input interface{}) interface{} {
	dmai := input.(*models.DistanceMarksAshoreImport)
	return &imports.DistanceMarksAshore{
		URL:         dmai.URL,
		FeatureType: dmai.FeatureType,
		SortBy:      dmai.SortBy,
	}
}

func importStretch(input interface{}) interface{} {
	sti := input.(*models.StretchImport)
	return &imports.Stretch{
		Name:      sti.Name,
		From:      sti.From,
		To:        sti.To,
		ObjNam:    sti.ObjNam,
		NObjNam:   sti.NObjNam,
		Source:    sti.Source,
		Date:      sti.Date,
		Countries: sti.Countries,
	}
}

func retry(a common.Attributes) (time.Time, *int, *time.Duration) {
	due, _ := a.Time("due")
	ret, ok := a.Int("retries")
	var retries *int
	if ok {
		retries = &ret
	}
	dur, ok := a.Duration("wait-retry")
	var duration *time.Duration
	if ok {
		duration = &dur
	}
	return due, retries, duration
}

func nilString(s *string) string {
	if s != nil {
		return *s
	}
	return ""
}

func manualImport(
	kind imports.JobKind,
	setup func(interface{}) interface{},
) func(interface{}, *http.Request, *sql.Conn) (JSONResult, error) {

	return func(input interface{}, req *http.Request, _ *sql.Conn) (
		jr JSONResult, err error) {

		what := setup(input)
		var serialized string
		if serialized, err = common.ToJSONString(what); err != nil {
			return
		}

		var (
			due       time.Time
			trys      *int
			waitRetry *time.Duration
			email     bool
		)

		if qctg, ok := input.(models.QueueConfigurationGetter); ok {
			qct := qctg.GetQueueConfiguration()
			if qct.Due != nil {
				due = *qct.Due
			}
			trys = qct.Trys
			waitRetry = qct.WaitRetry
			email = qct.EMail
		}

		session, _ := auth.GetSession(req)

		var jobID int64
		if jobID, err = imports.AddJob(
			kind,
			due,
			trys,
			waitRetry,
			session.User,
			email,
			serialized,
		); err != nil {
			return
		}

		log.Printf("info: added import #%d to queue\n", jobID)

		result := struct {
			ID int64 `json:"id"`
		}{
			ID: jobID,
		}

		jr = JSONResult{
			Code:   http.StatusCreated,
			Result: &result,
		}
		return
	}
}