xgo/stdlib/times.go

package stdlib

import (
	"time"

	"github.com/d5/tengo/v2"
)

var timesModule = map[string]tengo.Object{
	"format_ansic":        &tengo.String{Value: time.ANSIC},
	"format_unix_date":    &tengo.String{Value: time.UnixDate},
	"format_ruby_date":    &tengo.String{Value: time.RubyDate},
	"format_rfc822":       &tengo.String{Value: time.RFC822},
	"format_rfc822z":      &tengo.String{Value: time.RFC822Z},
	"format_rfc850":       &tengo.String{Value: time.RFC850},
	"format_rfc1123":      &tengo.String{Value: time.RFC1123},
	"format_rfc1123z":     &tengo.String{Value: time.RFC1123Z},
	"format_rfc3339":      &tengo.String{Value: time.RFC3339},
	"format_rfc3339_nano": &tengo.String{Value: time.RFC3339Nano},
	"format_kitchen":      &tengo.String{Value: time.Kitchen},
	"format_stamp":        &tengo.String{Value: time.Stamp},
	"format_stamp_milli":  &tengo.String{Value: time.StampMilli},
	"format_stamp_micro":  &tengo.String{Value: time.StampMicro},
	"format_stamp_nano":   &tengo.String{Value: time.StampNano},
	"nanosecond":          &tengo.Int{Value: int64(time.Nanosecond)},
	"microsecond":         &tengo.Int{Value: int64(time.Microsecond)},
	"millisecond":         &tengo.Int{Value: int64(time.Millisecond)},
	"second":              &tengo.Int{Value: int64(time.Second)},
	"minute":              &tengo.Int{Value: int64(time.Minute)},
	"hour":                &tengo.Int{Value: int64(time.Hour)},
	"january":             &tengo.Int{Value: int64(time.January)},
	"february":            &tengo.Int{Value: int64(time.February)},
	"march":               &tengo.Int{Value: int64(time.March)},
	"april":               &tengo.Int{Value: int64(time.April)},
	"may":                 &tengo.Int{Value: int64(time.May)},
	"june":                &tengo.Int{Value: int64(time.June)},
	"july":                &tengo.Int{Value: int64(time.July)},
	"august":              &tengo.Int{Value: int64(time.August)},
	"september":           &tengo.Int{Value: int64(time.September)},
	"october":             &tengo.Int{Value: int64(time.October)},
	"november":            &tengo.Int{Value: int64(time.November)},
	"december":            &tengo.Int{Value: int64(time.December)},
	"sleep": &tengo.UserFunction{
		Name:  "sleep",
		Value: timesSleep,
	}, // sleep(int)
	"parse_duration": &tengo.UserFunction{
		Name:  "parse_duration",
		Value: timesParseDuration,
	}, // parse_duration(str) => int
	"since": &tengo.UserFunction{
		Name:  "since",
		Value: timesSince,
	}, // since(time) => int
	"until": &tengo.UserFunction{
		Name:  "until",
		Value: timesUntil,
	}, // until(time) => int
	"duration_hours": &tengo.UserFunction{
		Name:  "duration_hours",
		Value: timesDurationHours,
	}, // duration_hours(int) => float
	"duration_minutes": &tengo.UserFunction{
		Name:  "duration_minutes",
		Value: timesDurationMinutes,
	}, // duration_minutes(int) => float
	"duration_nanoseconds": &tengo.UserFunction{
		Name:  "duration_nanoseconds",
		Value: timesDurationNanoseconds,
	}, // duration_nanoseconds(int) => int
	"duration_seconds": &tengo.UserFunction{
		Name:  "duration_seconds",
		Value: timesDurationSeconds,
	}, // duration_seconds(int) => float
	"duration_string": &tengo.UserFunction{
		Name:  "duration_string",
		Value: timesDurationString,
	}, // duration_string(int) => string
	"month_string": &tengo.UserFunction{
		Name:  "month_string",
		Value: timesMonthString,
	}, // month_string(int) => string
	"date": &tengo.UserFunction{
		Name:  "date",
		Value: timesDate,
	}, // date(year, month, day, hour, min, sec, nsec) => time
	"now": &tengo.UserFunction{
		Name:  "now",
		Value: timesNow,
	}, // now() => time
	"parse": &tengo.UserFunction{
		Name:  "parse",
		Value: timesParse,
	}, // parse(format, str) => time
	"unix": &tengo.UserFunction{
		Name:  "unix",
		Value: timesUnix,
	}, // unix(sec, nsec) => time
	"add": &tengo.UserFunction{
		Name:  "add",
		Value: timesAdd,
	}, // add(time, int) => time
	"add_date": &tengo.UserFunction{
		Name:  "add_date",
		Value: timesAddDate,
	}, // add_date(time, years, months, days) => time
	"sub": &tengo.UserFunction{
		Name:  "sub",
		Value: timesSub,
	}, // sub(t time, u time) => int
	"after": &tengo.UserFunction{
		Name:  "after",
		Value: timesAfter,
	}, // after(t time, u time) => bool
	"before": &tengo.UserFunction{
		Name:  "before",
		Value: timesBefore,
	}, // before(t time, u time) => bool
	"time_year": &tengo.UserFunction{
		Name:  "time_year",
		Value: timesTimeYear,
	}, // time_year(time) => int
	"time_month": &tengo.UserFunction{
		Name:  "time_month",
		Value: timesTimeMonth,
	}, // time_month(time) => int
	"time_day": &tengo.UserFunction{
		Name:  "time_day",
		Value: timesTimeDay,
	}, // time_day(time) => int
	"time_weekday": &tengo.UserFunction{
		Name:  "time_weekday",
		Value: timesTimeWeekday,
	}, // time_weekday(time) => int
	"time_hour": &tengo.UserFunction{
		Name:  "time_hour",
		Value: timesTimeHour,
	}, // time_hour(time) => int
	"time_minute": &tengo.UserFunction{
		Name:  "time_minute",
		Value: timesTimeMinute,
	}, // time_minute(time) => int
	"time_second": &tengo.UserFunction{
		Name:  "time_second",
		Value: timesTimeSecond,
	}, // time_second(time) => int
	"time_nanosecond": &tengo.UserFunction{
		Name:  "time_nanosecond",
		Value: timesTimeNanosecond,
	}, // time_nanosecond(time) => int
	"time_unix": &tengo.UserFunction{
		Name:  "time_unix",
		Value: timesTimeUnix,
	}, // time_unix(time) => int
	"time_unix_nano": &tengo.UserFunction{
		Name:  "time_unix_nano",
		Value: timesTimeUnixNano,
	}, // time_unix_nano(time) => int
	"time_format": &tengo.UserFunction{
		Name:  "time_format",
		Value: timesTimeFormat,
	}, // time_format(time, format) => string
	"time_location": &tengo.UserFunction{
		Name:  "time_location",
		Value: timesTimeLocation,
	}, // time_location(time) => string
	"time_string": &tengo.UserFunction{
		Name:  "time_string",
		Value: timesTimeString,
	}, // time_string(time) => string
	"is_zero": &tengo.UserFunction{
		Name:  "is_zero",
		Value: timesIsZero,
	}, // is_zero(time) => bool
	"to_local": &tengo.UserFunction{
		Name:  "to_local",
		Value: timesToLocal,
	}, // to_local(time) => time
	"to_utc": &tengo.UserFunction{
		Name:  "to_utc",
		Value: timesToUTC,
	}, // to_utc(time) => time
	"in_location": &tengo.UserFunction{
		Name:  "in_location",
		Value: timesInLocation,
	}, // in_location(time, location) => time
}

func timesSleep(args ...tengo.Object) (ret tengo.Object, err error) {
	if len(args) != 1 {
		err = tengo.ErrWrongNumArguments
		return
	}

	i1, ok := tengo.ToInt64(args[0])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "first",
			Expected: "int(compatible)",
			Found:    args[0].TypeName(),
		}
		return
	}

	time.Sleep(time.Duration(i1))
	ret = tengo.UndefinedValue

	return
}

func timesParseDuration(args ...tengo.Object) (
	ret tengo.Object,
	err error,
) {
	if len(args) != 1 {
		err = tengo.ErrWrongNumArguments
		return
	}

	s1, ok := tengo.ToString(args[0])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "first",
			Expected: "string(compatible)",
			Found:    args[0].TypeName(),
		}
		return
	}

	dur, err := time.ParseDuration(s1)
	if err != nil {
		ret = wrapError(err)
		return
	}

	ret = &tengo.Int{Value: int64(dur)}

	return
}

func timesSince(args ...tengo.Object) (
	ret tengo.Object,
	err error,
) {
	if len(args) != 1 {
		err = tengo.ErrWrongNumArguments
		return
	}

	t1, ok := tengo.ToTime(args[0])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "first",
			Expected: "time(compatible)",
			Found:    args[0].TypeName(),
		}
		return
	}

	ret = &tengo.Int{Value: int64(time.Since(t1))}

	return
}

func timesUntil(args ...tengo.Object) (
	ret tengo.Object,
	err error,
) {
	if len(args) != 1 {
		err = tengo.ErrWrongNumArguments
		return
	}

	t1, ok := tengo.ToTime(args[0])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "first",
			Expected: "time(compatible)",
			Found:    args[0].TypeName(),
		}
		return
	}

	ret = &tengo.Int{Value: int64(time.Until(t1))}

	return
}

func timesDurationHours(args ...tengo.Object) (
	ret tengo.Object,
	err error,
) {
	if len(args) != 1 {
		err = tengo.ErrWrongNumArguments
		return
	}

	i1, ok := tengo.ToInt64(args[0])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "first",
			Expected: "int(compatible)",
			Found:    args[0].TypeName(),
		}
		return
	}

	ret = &tengo.Float{Value: time.Duration(i1).Hours()}

	return
}

func timesDurationMinutes(args ...tengo.Object) (
	ret tengo.Object,
	err error,
) {
	if len(args) != 1 {
		err = tengo.ErrWrongNumArguments
		return
	}

	i1, ok := tengo.ToInt64(args[0])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "first",
			Expected: "int(compatible)",
			Found:    args[0].TypeName(),
		}
		return
	}

	ret = &tengo.Float{Value: time.Duration(i1).Minutes()}

	return
}

func timesDurationNanoseconds(args ...tengo.Object) (
	ret tengo.Object,
	err error,
) {
	if len(args) != 1 {
		err = tengo.ErrWrongNumArguments
		return
	}

	i1, ok := tengo.ToInt64(args[0])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "first",
			Expected: "int(compatible)",
			Found:    args[0].TypeName(),
		}
		return
	}

	ret = &tengo.Int{Value: time.Duration(i1).Nanoseconds()}

	return
}

func timesDurationSeconds(args ...tengo.Object) (
	ret tengo.Object,
	err error,
) {
	if len(args) != 1 {
		err = tengo.ErrWrongNumArguments
		return
	}

	i1, ok := tengo.ToInt64(args[0])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "first",
			Expected: "int(compatible)",
			Found:    args[0].TypeName(),
		}
		return
	}

	ret = &tengo.Float{Value: time.Duration(i1).Seconds()}

	return
}

func timesDurationString(args ...tengo.Object) (
	ret tengo.Object,
	err error,
) {
	if len(args) != 1 {
		err = tengo.ErrWrongNumArguments
		return
	}

	i1, ok := tengo.ToInt64(args[0])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "first",
			Expected: "int(compatible)",
			Found:    args[0].TypeName(),
		}
		return
	}

	ret = &tengo.String{Value: time.Duration(i1).String()}

	return
}

func timesMonthString(args ...tengo.Object) (
	ret tengo.Object,
	err error,
) {
	if len(args) != 1 {
		err = tengo.ErrWrongNumArguments
		return
	}

	i1, ok := tengo.ToInt64(args[0])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "first",
			Expected: "int(compatible)",
			Found:    args[0].TypeName(),
		}
		return
	}

	ret = &tengo.String{Value: time.Month(i1).String()}

	return
}

func timesDate(args ...tengo.Object) (
	ret tengo.Object,
	err error,
) {
	if len(args) < 7 || len(args) > 8 {
		err = tengo.ErrWrongNumArguments
		return
	}

	i1, ok := tengo.ToInt(args[0])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "first",
			Expected: "int(compatible)",
			Found:    args[0].TypeName(),
		}
		return
	}
	i2, ok := tengo.ToInt(args[1])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "second",
			Expected: "int(compatible)",
			Found:    args[1].TypeName(),
		}
		return
	}
	i3, ok := tengo.ToInt(args[2])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "third",
			Expected: "int(compatible)",
			Found:    args[2].TypeName(),
		}
		return
	}
	i4, ok := tengo.ToInt(args[3])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "fourth",
			Expected: "int(compatible)",
			Found:    args[3].TypeName(),
		}
		return
	}
	i5, ok := tengo.ToInt(args[4])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "fifth",
			Expected: "int(compatible)",
			Found:    args[4].TypeName(),
		}
		return
	}
	i6, ok := tengo.ToInt(args[5])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "sixth",
			Expected: "int(compatible)",
			Found:    args[5].TypeName(),
		}
		return
	}
	i7, ok := tengo.ToInt(args[6])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "seventh",
			Expected: "int(compatible)",
			Found:    args[6].TypeName(),
		}
		return
	}

	var loc *time.Location
	if len(args) == 8 {
		i8, ok := tengo.ToString(args[7])
		if !ok {
			err = tengo.ErrInvalidArgumentType{
				Name:     "eighth",
				Expected: "string(compatible)",
				Found:    args[7].TypeName(),
			}
			return
		}
		loc, err = time.LoadLocation(i8)
		if err != nil {
			ret = wrapError(err)
			return
		}
	} else {
		loc = time.Now().Location()
	}

	ret = &tengo.Time{
		Value: time.Date(i1,
			time.Month(i2), i3, i4, i5, i6, i7, loc),
	}

	return
}

func timesNow(args ...tengo.Object) (ret tengo.Object, err error) {
	if len(args) != 0 {
		err = tengo.ErrWrongNumArguments
		return
	}

	ret = &tengo.Time{Value: time.Now()}

	return
}

func timesParse(args ...tengo.Object) (ret tengo.Object, err error) {
	if len(args) != 2 {
		err = tengo.ErrWrongNumArguments
		return
	}

	s1, ok := tengo.ToString(args[0])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "first",
			Expected: "string(compatible)",
			Found:    args[0].TypeName(),
		}
		return
	}

	s2, ok := tengo.ToString(args[1])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "second",
			Expected: "string(compatible)",
			Found:    args[1].TypeName(),
		}
		return
	}

	parsed, err := time.Parse(s1, s2)
	if err != nil {
		ret = wrapError(err)
		return
	}

	ret = &tengo.Time{Value: parsed}

	return
}

func timesUnix(args ...tengo.Object) (ret tengo.Object, err error) {
	if len(args) != 2 {
		err = tengo.ErrWrongNumArguments
		return
	}

	i1, ok := tengo.ToInt64(args[0])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "first",
			Expected: "int(compatible)",
			Found:    args[0].TypeName(),
		}
		return
	}

	i2, ok := tengo.ToInt64(args[1])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "second",
			Expected: "int(compatible)",
			Found:    args[1].TypeName(),
		}
		return
	}

	ret = &tengo.Time{Value: time.Unix(i1, i2)}

	return
}

func timesAdd(args ...tengo.Object) (ret tengo.Object, err error) {
	if len(args) != 2 {
		err = tengo.ErrWrongNumArguments
		return
	}

	t1, ok := tengo.ToTime(args[0])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "first",
			Expected: "time(compatible)",
			Found:    args[0].TypeName(),
		}
		return
	}

	i2, ok := tengo.ToInt64(args[1])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "second",
			Expected: "int(compatible)",
			Found:    args[1].TypeName(),
		}
		return
	}

	ret = &tengo.Time{Value: t1.Add(time.Duration(i2))}

	return
}

func timesSub(args ...tengo.Object) (ret tengo.Object, err error) {
	if len(args) != 2 {
		err = tengo.ErrWrongNumArguments
		return
	}

	t1, ok := tengo.ToTime(args[0])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "first",
			Expected: "time(compatible)",
			Found:    args[0].TypeName(),
		}
		return
	}

	t2, ok := tengo.ToTime(args[1])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "second",
			Expected: "time(compatible)",
			Found:    args[1].TypeName(),
		}
		return
	}

	ret = &tengo.Int{Value: int64(t1.Sub(t2))}

	return
}

func timesAddDate(args ...tengo.Object) (ret tengo.Object, err error) {
	if len(args) != 4 {
		err = tengo.ErrWrongNumArguments
		return
	}

	t1, ok := tengo.ToTime(args[0])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "first",
			Expected: "time(compatible)",
			Found:    args[0].TypeName(),
		}
		return
	}

	i2, ok := tengo.ToInt(args[1])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "second",
			Expected: "int(compatible)",
			Found:    args[1].TypeName(),
		}
		return
	}

	i3, ok := tengo.ToInt(args[2])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "third",
			Expected: "int(compatible)",
			Found:    args[2].TypeName(),
		}
		return
	}

	i4, ok := tengo.ToInt(args[3])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "fourth",
			Expected: "int(compatible)",
			Found:    args[3].TypeName(),
		}
		return
	}

	ret = &tengo.Time{Value: t1.AddDate(i2, i3, i4)}

	return
}

func timesAfter(args ...tengo.Object) (ret tengo.Object, err error) {
	if len(args) != 2 {
		err = tengo.ErrWrongNumArguments
		return
	}

	t1, ok := tengo.ToTime(args[0])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "first",
			Expected: "time(compatible)",
			Found:    args[0].TypeName(),
		}
		return
	}

	t2, ok := tengo.ToTime(args[1])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "second",
			Expected: "time(compatible)",
			Found:    args[1].TypeName(),
		}
		return
	}

	if t1.After(t2) {
		ret = tengo.TrueValue
	} else {
		ret = tengo.FalseValue
	}

	return
}

func timesBefore(args ...tengo.Object) (ret tengo.Object, err error) {
	if len(args) != 2 {
		err = tengo.ErrWrongNumArguments
		return
	}

	t1, ok := tengo.ToTime(args[0])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "first",
			Expected: "time(compatible)",
			Found:    args[0].TypeName(),
		}
		return
	}

	t2, ok := tengo.ToTime(args[1])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "second",
			Expected: "time(compatible)",
			Found:    args[0].TypeName(),
		}
		return
	}

	if t1.Before(t2) {
		ret = tengo.TrueValue
	} else {
		ret = tengo.FalseValue
	}

	return
}

func timesTimeYear(args ...tengo.Object) (ret tengo.Object, err error) {
	if len(args) != 1 {
		err = tengo.ErrWrongNumArguments
		return
	}

	t1, ok := tengo.ToTime(args[0])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "first",
			Expected: "time(compatible)",
			Found:    args[0].TypeName(),
		}
		return
	}

	ret = &tengo.Int{Value: int64(t1.Year())}

	return
}

func timesTimeMonth(args ...tengo.Object) (ret tengo.Object, err error) {
	if len(args) != 1 {
		err = tengo.ErrWrongNumArguments
		return
	}

	t1, ok := tengo.ToTime(args[0])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "first",
			Expected: "time(compatible)",
			Found:    args[0].TypeName(),
		}
		return
	}

	ret = &tengo.Int{Value: int64(t1.Month())}

	return
}

func timesTimeDay(args ...tengo.Object) (ret tengo.Object, err error) {
	if len(args) != 1 {
		err = tengo.ErrWrongNumArguments
		return
	}

	t1, ok := tengo.ToTime(args[0])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "first",
			Expected: "time(compatible)",
			Found:    args[0].TypeName(),
		}
		return
	}

	ret = &tengo.Int{Value: int64(t1.Day())}

	return
}

func timesTimeWeekday(args ...tengo.Object) (ret tengo.Object, err error) {
	if len(args) != 1 {
		err = tengo.ErrWrongNumArguments
		return
	}

	t1, ok := tengo.ToTime(args[0])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "first",
			Expected: "time(compatible)",
			Found:    args[0].TypeName(),
		}
		return
	}

	ret = &tengo.Int{Value: int64(t1.Weekday())}

	return
}

func timesTimeHour(args ...tengo.Object) (ret tengo.Object, err error) {
	if len(args) != 1 {
		err = tengo.ErrWrongNumArguments
		return
	}

	t1, ok := tengo.ToTime(args[0])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "first",
			Expected: "time(compatible)",
			Found:    args[0].TypeName(),
		}
		return
	}

	ret = &tengo.Int{Value: int64(t1.Hour())}

	return
}

func timesTimeMinute(args ...tengo.Object) (ret tengo.Object, err error) {
	if len(args) != 1 {
		err = tengo.ErrWrongNumArguments
		return
	}

	t1, ok := tengo.ToTime(args[0])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "first",
			Expected: "time(compatible)",
			Found:    args[0].TypeName(),
		}
		return
	}

	ret = &tengo.Int{Value: int64(t1.Minute())}

	return
}

func timesTimeSecond(args ...tengo.Object) (ret tengo.Object, err error) {
	if len(args) != 1 {
		err = tengo.ErrWrongNumArguments
		return
	}

	t1, ok := tengo.ToTime(args[0])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "first",
			Expected: "time(compatible)",
			Found:    args[0].TypeName(),
		}
		return
	}

	ret = &tengo.Int{Value: int64(t1.Second())}

	return
}

func timesTimeNanosecond(args ...tengo.Object) (
	ret tengo.Object,
	err error,
) {
	if len(args) != 1 {
		err = tengo.ErrWrongNumArguments
		return
	}

	t1, ok := tengo.ToTime(args[0])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "first",
			Expected: "time(compatible)",
			Found:    args[0].TypeName(),
		}
		return
	}

	ret = &tengo.Int{Value: int64(t1.Nanosecond())}

	return
}

func timesTimeUnix(args ...tengo.Object) (ret tengo.Object, err error) {
	if len(args) != 1 {
		err = tengo.ErrWrongNumArguments
		return
	}

	t1, ok := tengo.ToTime(args[0])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "first",
			Expected: "time(compatible)",
			Found:    args[0].TypeName(),
		}
		return
	}

	ret = &tengo.Int{Value: t1.Unix()}

	return
}

func timesTimeUnixNano(args ...tengo.Object) (
	ret tengo.Object,
	err error,
) {
	if len(args) != 1 {
		err = tengo.ErrWrongNumArguments
		return
	}

	t1, ok := tengo.ToTime(args[0])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "first",
			Expected: "time(compatible)",
			Found:    args[0].TypeName(),
		}
		return
	}

	ret = &tengo.Int{Value: t1.UnixNano()}

	return
}

func timesTimeFormat(args ...tengo.Object) (ret tengo.Object, err error) {
	if len(args) != 2 {
		err = tengo.ErrWrongNumArguments
		return
	}

	t1, ok := tengo.ToTime(args[0])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "first",
			Expected: "time(compatible)",
			Found:    args[0].TypeName(),
		}
		return
	}

	s2, ok := tengo.ToString(args[1])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "second",
			Expected: "string(compatible)",
			Found:    args[1].TypeName(),
		}
		return
	}

	s := t1.Format(s2)
	if len(s) > tengo.MaxStringLen {

		return nil, tengo.ErrStringLimit
	}

	ret = &tengo.String{Value: s}

	return
}

func timesIsZero(args ...tengo.Object) (ret tengo.Object, err error) {
	if len(args) != 1 {
		err = tengo.ErrWrongNumArguments
		return
	}

	t1, ok := tengo.ToTime(args[0])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "first",
			Expected: "time(compatible)",
			Found:    args[0].TypeName(),
		}
		return
	}

	if t1.IsZero() {
		ret = tengo.TrueValue
	} else {
		ret = tengo.FalseValue
	}

	return
}

func timesToLocal(args ...tengo.Object) (ret tengo.Object, err error) {
	if len(args) != 1 {
		err = tengo.ErrWrongNumArguments
		return
	}

	t1, ok := tengo.ToTime(args[0])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "first",
			Expected: "time(compatible)",
			Found:    args[0].TypeName(),
		}
		return
	}

	ret = &tengo.Time{Value: t1.Local()}

	return
}

func timesToUTC(args ...tengo.Object) (ret tengo.Object, err error) {
	if len(args) != 1 {
		err = tengo.ErrWrongNumArguments
		return
	}

	t1, ok := tengo.ToTime(args[0])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "first",
			Expected: "time(compatible)",
			Found:    args[0].TypeName(),
		}
		return
	}

	ret = &tengo.Time{Value: t1.UTC()}

	return
}

func timesTimeLocation(args ...tengo.Object) (
	ret tengo.Object,
	err error,
) {
	if len(args) != 1 {
		err = tengo.ErrWrongNumArguments
		return
	}

	t1, ok := tengo.ToTime(args[0])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "first",
			Expected: "time(compatible)",
			Found:    args[0].TypeName(),
		}
		return
	}

	ret = &tengo.String{Value: t1.Location().String()}

	return
}

func timesInLocation(args ...tengo.Object) (
	ret tengo.Object,
	err error,
) {
	if len(args) != 2 {
		err = tengo.ErrWrongNumArguments
		return
	}

	t1, ok := tengo.ToTime(args[0])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "first",
			Expected: "time(compatible)",
			Found:    args[0].TypeName(),
		}
		return
	}

	s2, ok := tengo.ToString(args[1])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "second",
			Expected: "string(compatible)",
			Found:    args[1].TypeName(),
		}
		return
	}

	location, err := time.LoadLocation(s2)
	if err != nil {
		ret = wrapError(err)
		return
	}

	ret = &tengo.Time{Value: t1.In(location)}

	return
}

func timesTimeString(args ...tengo.Object) (ret tengo.Object, err error) {
	if len(args) != 1 {
		err = tengo.ErrWrongNumArguments
		return
	}

	t1, ok := tengo.ToTime(args[0])
	if !ok {
		err = tengo.ErrInvalidArgumentType{
			Name:     "first",
			Expected: "time(compatible)",
			Found:    args[0].TypeName(),
		}
		return
	}

	ret = &tengo.String{Value: t1.String()}

	return
}