// Copyright 2025 Dolthub, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package functions

import (
	"strings"
	"time"

	"github.com/cockroachdb/apd/v3"
	cerrors "github.com/cockroachdb/errors"
	"github.com/dolthub/go-mysql-server/sql"

	"github.com/dolthub/doltgresql/postgres/parser/duration"
	"github.com/dolthub/doltgresql/postgres/parser/timeofday"
	"github.com/dolthub/doltgresql/postgres/parser/timetz"
	"github.com/dolthub/doltgresql/server/functions/framework"
	pgtypes "github.com/dolthub/doltgresql/server/types"
)

// initDatePart registers the functions to the catalog.
func initDatePart() {
	framework.RegisterFunction(date_part_text_date)
	framework.RegisterFunction(date_part_text_time)
	framework.RegisterFunction(date_part_text_timetz)
	framework.RegisterFunction(date_part_text_timestamp)
	framework.RegisterFunction(date_part_text_timestamptz)
	framework.RegisterFunction(date_part_text_interval)
}

// date_part_text_date represents the PostgreSQL date_part function for date type.
var date_part_text_date = framework.Function2{
	Name:       "date_part",
	Return:     pgtypes.Float64,
	Parameters: [2]*pgtypes.DoltgresType{pgtypes.Text, pgtypes.Date},
	Strict:     true,
	Callable: func(ctx *sql.Context, _ [3]*pgtypes.DoltgresType, val1, val2 any) (any, error) {
		field := val1.(string)
		dateVal := val2.(time.Time)
		switch strings.ToLower(field) {
		case "hour", "hours", "microsecond", "microseconds", "millisecond", "milliseconds",
			"minute", "minutes", "second", "seconds", "timezone", "timezone_hour", "timezone_minute":
			return nil, ErrUnitNotSupported.New(field, "date")
		case "epoch":
			return float64(dateVal.UnixMicro()) / 1000000, nil
		default:
			result, err := getFieldFromTimeVal(field, dateVal)
			if err != nil {
				return nil, err
			}
			f, _ := result.Float64()
			return f, nil
		}
	},
}

// date_part_text_time represents the PostgreSQL date_part function for time type.
var date_part_text_time = framework.Function2{
	Name:       "date_part",
	Return:     pgtypes.Float64,
	Parameters: [2]*pgtypes.DoltgresType{pgtypes.Text, pgtypes.Time},
	Strict:     true,
	Callable: func(ctx *sql.Context, _ [3]*pgtypes.DoltgresType, val1, val2 any) (any, error) {
		field := val1.(string)
		timeVal := val2.(timeofday.TimeOfDay).ToTime()
		switch strings.ToLower(field) {
		case "century", "centuries", "day", "days", "decade", "decades", "dow", "doy",
			"isodow", "isoyear", "julian", "millennium", "millenniums", "month", "months",
			"quarter", "timezone", "timezone_hour", "timezone_minute", "week", "year", "years":
			return nil, ErrUnitNotSupported.New(field, "time without time zone")
		default:
			result, err := getFieldFromTimeVal(field, timeVal)
			if err != nil {
				return nil, err
			}
			f, _ := result.Float64()
			return f, nil
		}
	},
}

// date_part_text_timetz represents the PostgreSQL date_part function for time with time zone type.
var date_part_text_timetz = framework.Function2{
	Name:       "date_part",
	Return:     pgtypes.Float64,
	Parameters: [2]*pgtypes.DoltgresType{pgtypes.Text, pgtypes.TimeTZ},
	Strict:     true,
	Callable: func(ctx *sql.Context, _ [3]*pgtypes.DoltgresType, val1, val2 any) (any, error) {
		field := val1.(string)
		timetzVal := val2.(timetz.TimeTZ).ToTime()
		_, currentOffset := timetzVal.Zone()
		switch strings.ToLower(field) {
		case "century", "centuries", "day", "days", "decade", "decades", "dow", "doy",
			"isodow", "isoyear", "julian", "millennium", "millenniums", "month", "months",
			"quarter", "week", "year", "years":
			return nil, ErrUnitNotSupported.New(field, "time with time zone")
		case "timezone":
			return float64(-currentOffset), nil
		case "timezone_hour":
			return float64(-currentOffset / 3600), nil
		case "timezone_minute":
			return float64((-currentOffset % 3600) / 60), nil
		default:
			result, err := getFieldFromTimeVal(field, timetzVal)
			if err != nil {
				return nil, err
			}
			f, _ := result.Float64()
			return f, nil
		}
	},
}

// date_part_text_timestamp represents the PostgreSQL date_part function for timestamp type.
var date_part_text_timestamp = framework.Function2{
	Name:       "date_part",
	Return:     pgtypes.Float64,
	Parameters: [2]*pgtypes.DoltgresType{pgtypes.Text, pgtypes.Timestamp},
	Strict:     true,
	Callable: func(ctx *sql.Context, _ [3]*pgtypes.DoltgresType, val1, val2 any) (any, error) {
		field := val1.(string)
		tsVal := val2.(time.Time)
		switch strings.ToLower(field) {
		case "timezone", "timezone_hour", "timezone_minute":
			return nil, ErrUnitNotSupported.New(field, "timestamp without time zone")
		default:
			result, err := getFieldFromTimeVal(field, tsVal)
			if err != nil {
				return nil, err
			}
			f, _ := result.Float64()
			return f, nil
		}
	},
}

// date_part_text_timestamptz represents the PostgreSQL date_part function for timestamp with time zone type.
var date_part_text_timestamptz = framework.Function2{
	Name:       "date_part",
	Return:     pgtypes.Float64,
	Parameters: [2]*pgtypes.DoltgresType{pgtypes.Text, pgtypes.TimestampTZ},
	Strict:     true,
	Callable: func(ctx *sql.Context, _ [3]*pgtypes.DoltgresType, val1, val2 any) (any, error) {
		field := val1.(string)
		loc, err := GetServerLocation(ctx)
		if err != nil {
			return nil, err
		}
		tstzVal := val2.(time.Time).In(loc)
		switch strings.ToLower(field) {
		case "timezone":
			// TODO: postgres seem to use server timezone regardless of input value
			return float64(-28800), nil
		case "timezone_hour":
			// TODO: postgres seem to use server timezone regardless of input value
			return float64(-8), nil
		case "timezone_minute":
			// TODO: postgres seem to use server timezone regardless of input value
			return float64(0), nil
		default:
			result, err := getFieldFromTimeVal(field, tstzVal)
			if err != nil {
				return nil, err
			}
			f, _ := result.Float64()
			return f, nil
		}
	},
}

// date_part_text_interval represents the PostgreSQL date_part function for interval type.
var date_part_text_interval = framework.Function2{
	Name:       "date_part",
	Return:     pgtypes.Float64,
	Parameters: [2]*pgtypes.DoltgresType{pgtypes.Text, pgtypes.Interval},
	Strict:     true,
	Callable: func(ctx *sql.Context, _ [3]*pgtypes.DoltgresType, val1, val2 any) (any, error) {
		field := val1.(string)
		dur := val2.(duration.Duration)

		// This mirrors the exact logic from extract_text_interval
		switch strings.ToLower(field) {
		case "century", "centuries":
			dec, err := numericFloor(float64(dur.Months) / 12 / 100)
			if err != nil {
				return nil, err
			}
			f, _ := dec.Float64()
			return f, nil
		case "day", "days":
			return float64(dur.Days), nil
		case "decade", "decades":
			dec, err := numericFloor(float64(dur.Months) / 12 / 10)
			if err != nil {
				return nil, err
			}
			f, _ := dec.Float64()
			return f, nil
		case "epoch":
			epoch := float64(duration.SecsPerDay*duration.DaysPerMonth*dur.Months) + float64(duration.SecsPerDay*dur.Days) +
				(float64(dur.Nanos()) / float64(NanosPerSec))
			return epoch, nil
		case "hour", "hours":
			hours := float64(dur.Nanos()) / float64(NanosPerSec*duration.SecsPerHour)
			dec, err := numericFloor(hours)
			if err != nil {
				return nil, err
			}
			f, _ := dec.Float64()
			return f, nil
		case "microsecond", "microseconds":
			secondsInNanos := dur.Nanos() % (NanosPerSec * duration.SecsPerMinute)
			microseconds := float64(secondsInNanos) / float64(NanosPerMicro)
			return microseconds, nil
		case "millennium", "millenniums":
			dec, err := numericFloor(float64(dur.Months) / 12 / 1000)
			if err != nil {
				return nil, err
			}
			f, _ := dec.Float64()
			return f, nil
		case "millisecond", "milliseconds":
			secondsInNanos := dur.Nanos() % (NanosPerSec * duration.SecsPerMinute)
			milliseconds := float64(secondsInNanos) / float64(NanosPerMilli)
			return milliseconds, nil
		case "minute", "minutes":
			minutesInNanos := dur.Nanos() % (NanosPerSec * duration.SecsPerHour)
			minutes := float64(minutesInNanos) / float64(NanosPerSec*duration.SecsPerMinute)
			dec, err := numericFloor(minutes)
			if err != nil {
				return nil, err
			}
			f, _ := dec.Float64()
			return f, nil
		case "month", "months":
			return float64(dur.Months % 12), nil
		case "quarter":
			return float64((dur.Months%12-1)/3 + 1), nil
		case "second", "seconds":
			secondsInNanos := dur.Nanos() % (NanosPerSec * duration.SecsPerMinute)
			seconds := float64(secondsInNanos) / float64(NanosPerSec)
			return seconds, nil
		case "year", "years":
			dec, err := numericFloor(float64(dur.Months) / 12)
			if err != nil {
				return nil, err
			}
			f, _ := dec.Float64()
			return f, nil
		case "dow", "doy", "isodow", "isoyear", "julian", "timezone", "timezone_hour", "timezone_minute", "week":
			return nil, ErrUnitNotSupported.New(field, "interval")
		default:
			return nil, ErrUnitNotSupported.New(field, "interval")
		}
	},
}

func numericFloor(val any) (*apd.Decimal, error) {
	switch val.(type) {
	case int64, float64:
		// expects these types to Scan from
	default:
		return nil, cerrors.Errorf("invalid type for numeric convert: %T", val)
	}
	dec := new(apd.Decimal)
	err := dec.Scan(val)
	if err != nil {
		return nil, err
	}
	_, err = sql.DecimalCtx.Floor(dec, dec)
	if err != nil {
		return nil, err
	}
	return dec, nil
}