package net.filebot.web;

import static net.filebot.Logging.*;

import java.io.Serializable;
import java.time.Instant;
import java.time.LocalDate;
import java.time.ZoneOffset;
import java.time.ZonedDateTime;
import java.time.chrono.ChronoLocalDate;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.Locale;
import java.util.Objects;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class SimpleDate implements Serializable, Comparable<Object> {

        protected int year;
        protected int month;
        protected int day;

        public SimpleDate() {
                // used by deserializer
        }

        public SimpleDate(int year, int month, int day) {
                this.year = year;
                this.month = month;
                this.day = day;
        }

        public SimpleDate(LocalDate date) {
                this.year = date.getYear();
                this.month = date.getMonthValue();
                this.day = date.getDayOfMonth();
        }

        public SimpleDate(int year) {
                this(year, 1, 1);
        }

        public int getYear() {
                return year;
        }

        public int getMonth() {
                return month;
        }

        public int getDay() {
                return day;
        }

        @Override
        public boolean equals(Object obj) {
                if (obj instanceof SimpleDate) {
                        SimpleDate other = (SimpleDate) obj;
                        return year == other.year && month == other.month && day == other.day;
                } else if (obj instanceof CharSequence) {
                        return toString().equals(obj.toString());
                }
                return super.equals(obj);
        }

        @Override
        public int compareTo(Object other) {
                if (other instanceof SimpleDate) {
                        return compareTo((SimpleDate) other);
                }
                if (other instanceof ChronoLocalDate) {
                        return compareTo((ChronoLocalDate) other);
                }
                if (other instanceof CharSequence) {
                        SimpleDate otherDate = parse(other.toString());
                        if (otherDate != null) {
                                return compareTo(otherDate);
                        }
                }
                throw new IllegalArgumentException("Bad Date: " + other);
        }

        public int compareTo(SimpleDate other) {
                return toLocalDate().compareTo(other.toLocalDate());
        }

        public int compareTo(ChronoLocalDate other) {
                return toLocalDate().compareTo(other);
        }

        public int compareTo(Instant other) {
                return toInstant().compareTo(other);
        }

        public SimpleDate plus(int days) {
                return new SimpleDate(toLocalDate().plusDays(days));
        }

        public SimpleDate minus(int days) {
                return new SimpleDate(toLocalDate().minusDays(days));
        }

        public long minus(SimpleDate other) {
                return getEpochDay() - other.getEpochDay();
        }

        @Override
        public int hashCode() {
                return Objects.hash(year, month, day);
        }

        @Override
        public SimpleDate clone() {
                return new SimpleDate(year, month, day);
        }

        public String format(String pattern) {
                return format(pattern, Locale.US);
        }

        public String format(String pattern, Locale locale) {
                return DateTimeFormatter.ofPattern(pattern, locale).format(toLocalDate());
        }

        public LocalDate toLocalDate() {
                try {
                        return LocalDate.of(year, month, day);
                } catch (Exception e) {
                        throw new IllegalStateException("Bad Date: " + this, e);
                }
        }

        public Instant toInstant() {
                return toLocalDate().atStartOfDay(ZoneOffset.UTC).toInstant();
        }

        public long getEpochDay() {
                return ChronoUnit.DAYS.between(Instant.EPOCH, toInstant());
        }

        public long getTimeStamp() {
                return toInstant().toEpochMilli();
        }

        @Override
        public String toString() {
                return String.format(Locale.ROOT, "%04d-%02d-%02d", year, month, day);
        }

        public static SimpleDate now() {
                return new SimpleDate(LocalDate.now());
        }

        public static SimpleDate from(Instant instant) {
                return instant == null ? null : new SimpleDate(instant.atOffset(ZoneOffset.UTC).toLocalDate());
        }

        public static SimpleDate from(ZonedDateTime date) {
                return date == null ? null : new SimpleDate(date.toLocalDate());
        }

        public static SimpleDate of(int year, int month, int day) {
                return new SimpleDate(LocalDate.of(year, month, day));
        }

        public static SimpleDate parse(String date) {
                if (date == null || date.isEmpty()) {
                        return null;
                }

                Matcher m = DATE_FORMAT.matcher(date);
                if (m.matches()) {
                        int year = Integer.parseInt(m.group(1));
                        int month = Integer.parseInt(m.group(2));
                        int day = Integer.parseInt(m.group(3));

                        try {
                                return new SimpleDate(LocalDate.of(year, month, day));
                        } catch (Exception e) {
                                debug.finest(message("Bad Date", date));
                        }
                }

                return null;
        }

        public static final Pattern DATE_FORMAT = Pattern.compile("(\\d{4})\\D(\\d{1,2})\\D(\\d{1,2})");

}