// 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{}, common.Attributes, bool) {
	bi := input.(*models.BottleneckImport)
	bn := &imports.Bottleneck{
		URL:      bi.URL,
		Insecure: bi.Insecure,
	}
	return bn, bi.Attributes, bi.SendEmail
}

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

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

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

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

func importWaterwayGauge(input interface{}) (interface{}, common.Attributes, bool) {
	wgi := input.(*models.WaterwayGaugeImport)
	username, _ := wgi.Attributes.Get("username")
	password, _ := wgi.Attributes.Get("password")
	insecure := wgi.Attributes.Bool("insecure")
	wg := &imports.WaterwayGauge{
		URL:      wgi.URL,
		Username: username,
		Password: password,
		Insecure: insecure,
	}
	return wg, wgi.Attributes, wgi.SendEmail
}

func importDistancemarksVirtual(input interface{}) (interface{}, common.Attributes, bool) {
	dmvi := input.(*models.DistanceMarksVirtualImport)
	username, _ := dmvi.Attributes.Get("username")
	password, _ := dmvi.Attributes.Get("password")
	insecure := dmvi.Attributes.Bool("insecure")
	wg := &imports.DistanceMarksVirtual{
		URL:      dmvi.URL,
		Username: username,
		Password: password,
		Insecure: insecure,
	}
	return wg, dmvi.Attributes, dmvi.SendEmail
}

func importFairwayDimension(input interface{}) (interface{}, common.Attributes, bool) {
	fdi := input.(*models.FairwayDimensionImport)
	fd := &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,
	}
	return fd, fdi.Attributes, fdi.SendEmail
}

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

func importStretch(input interface{}) (interface{}, common.Attributes, bool) {
	sti := input.(*models.StretchImport)
	st := &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,
	}
	return st, sti.Attributes, sti.SendEmail
}

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 manualImport(
	kind imports.JobKind,
	setup func(interface{}) (interface{}, common.Attributes, bool),
) func(interface{}, *http.Request, *sql.Conn) (JSONResult, error) {

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

		what, attrs, sendEmail := setup(input)

		due, retries, waitRetry := retry(attrs)

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

		session, _ := auth.GetSession(req)

		var jobID int64
		if jobID, err = imports.AddJob(
			kind,
			due,
			retries,
			waitRetry,
			session.User,
			sendEmail,
			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
	}
}