package store

import (
	"database/sql"
	"errors"
	"log"
	"time"

	"git.bronku.xyz/bronku/cake-order-tracker/config"
	"git.bronku.xyz/bronku/cake-order-tracker/models"
)

func dateRangeParams(from, to time.Time) (start, end string) {
	start = from.Format(config.DateFormat) + " 00:00"
	end = to.Format(config.DateFormat) + " 99:99"
	if to.IsZero() {
		end = "9999-99-99 99:99"
	}
	return
}

func (s *Store) scanOrderRow(row *sql.Rows) (models.Order, error) {
	var out models.Order
	var orderDate, deliveryDate string
	err := row.Scan(&out.ID, &out.Name, &out.Surname, &out.Phone, &out.Location, &orderDate, &deliveryDate, &out.Status, &out.Paid)
	if err != nil {
		return out, err
	}
	out.Accepted, err = time.Parse(config.DateTimeFormat, orderDate)
	if err != nil {
		return out, err
	}
	out.Date, err = time.Parse(config.DateTimeFormat, deliveryDate)
	if err != nil {
		return out, err
	}
	return out, nil
}

func (s *Store) loadOrderCakes(orderID int) ([]models.Cake, error) {
	var cakes []models.Cake
	rows, err := s.db.Query("select cake, amount from ordered_cake where customer_order = ?;", orderID)
	if err != nil {
		return cakes, err
	}
	defer rows.Close()
	for rows.Next() {
		var c models.Cake
		if err := rows.Scan(&c.ID, &c.Amount); err != nil {
			return cakes, err
		}
		cakeData, err := s.GetCake(c.ID)
		if err != nil {
			continue
		}
		c.Name = cakeData.Name
		c.Price = cakeData.Price
		cakes = append(cakes, c)
	}
	return cakes, rows.Err()
}

func (s *Store) getOrdersFromQuery(query string, args ...any) ([]models.Order, error) {
	var out []models.Order
	rows, err := s.db.Query(query, args...)
	if err != nil {
		return out, err
	}
	defer rows.Close()

	for rows.Next() {
		order, err := s.scanOrderRow(rows)
		if err != nil {
			continue
		}
		order.Cakes, err = s.loadOrderCakes(order.ID)
		if err != nil {
			continue
		}
		order.SpecialCakes, err = s.GetSpecialCakes(order.ID)
		if err != nil {
			continue
		}
		out = append(out, order)
	}

	return out, nil
}

func (s *Store) GetOrder(id int) (models.Order, error) {
	query := "select * from customer_order where id = ?;"
	out, err := s.getOrdersFromQuery(query, id)
	if err != nil {
		return models.Order{}, err
	}
	if len(out) < 1 {
		return models.Order{}, errors.New("no output order")
	}
	return out[0], nil
}

func (s *Store) GetOrders(from, to time.Time) ([]models.Order, error) {
	start, end := dateRangeParams(from, to)
	query := "select * from customer_order where status != 'picked_up' and delivery_date >= ? and delivery_date <= ? ;"
	return s.getOrdersFromQuery(query, start, end)
}

func (s *Store) GetOrderCounts() (models.OrderCounts, error) {
	var c models.OrderCounts
	err := s.db.QueryRow(`
		SELECT COUNT(*),
		       COALESCE(SUM(CASE WHEN substr(delivery_date, 1, 10) = date('now') THEN 1 ELSE 0 END), 0)
		FROM customer_order WHERE status != 'picked_up'
	`).Scan(&c.Active, &c.DueToday)
	return c, err
}

func (s *Store) GetCakeCounts(from, to time.Time) ([]models.CakeCount, error) {
	start, end := dateRangeParams(from, to)
	rows, err := s.db.Query(`
		SELECT c.id, c.name, COALESCE(SUM(oc.amount), 0)
		FROM ordered_cake oc
		JOIN customer_order co ON oc.customer_order = co.id
		JOIN cake c ON oc.cake = c.id
		WHERE co.status != 'picked_up' AND co.delivery_date >= ? AND co.delivery_date <= ?
		GROUP BY oc.cake
		ORDER BY SUM(oc.amount) DESC
	`, start, end)
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	var out []models.CakeCount
	for rows.Next() {
		var cc models.CakeCount
		if err := rows.Scan(&cc.ID, &cc.Name, &cc.Amount); err != nil {
			return nil, err
		}
		out = append(out, cc)
	}
	return out, rows.Err()
}

func (s *Store) UpdateOrderContents(tx *sql.Tx, newOrder models.Order) error {
	q := "delete from ordered_cake where customer_order = ?;"
	_, err := tx.Exec(q, newOrder.ID)
	if err != nil {
		return err
	}

	q = "insert into ordered_cake(customer_order, cake, amount) values (?,?,?);"
	for _, e := range newOrder.Cakes {
		_, err := tx.Exec(q, newOrder.ID, e.ID, e.Amount)
		if err != nil {
			return err
		}
	}

	return s.SaveSpecialCakes(tx, newOrder.ID, newOrder.SpecialCakes)
}

func (s *Store) UpdateOrder(newOrder models.Order) error {
	_, err := s.GetOrder(newOrder.ID)
	if err != nil {
		return err
	}
	q := "update customer_order set name = ?, surname = ?, phone = ?, location = ?, order_date = ?, delivery_date = ?, status = ?, paid = ? where id = ?;"

	accepted := newOrder.Accepted.Format(config.DateTimeFormat)
	date := newOrder.Date.Format(config.DateTimeFormat)

	tx, err := s.db.Begin()
	if err != nil {
		return err
	}

	_, err = tx.Exec(q, newOrder.Name, newOrder.Surname, newOrder.Phone, newOrder.Location, accepted, date, newOrder.Status, newOrder.Paid, newOrder.ID)
	if err != nil {
		_ = tx.Rollback()
		return err
	}

	err = s.UpdateOrderContents(tx, newOrder)
	if err != nil {
		_ = tx.Rollback()
		return err
	}

	err = tx.Commit()
	log.Printf("UPDATE order id=%d name=%q status=%q", newOrder.ID, newOrder.Name, newOrder.Status)
	return nil
}

func (s *Store) SaveOrder(newOrder models.Order) (int, error) {
	if newOrder.ID != 0 {
		return newOrder.ID, s.UpdateOrder(newOrder)
	}
	q := "insert into customer_order(name, surname, phone, location, order_date, delivery_date, status, paid) values (?, ?, ?, ?, ?, ?, ?, ?);"

	tx, err := s.db.Begin()
	if err != nil {
		return 0, err
	}

	accepted := newOrder.Accepted.Format(config.DateTimeFormat)
	date := newOrder.Date.Format(config.DateTimeFormat)
	result, err := tx.Exec(q, newOrder.Name, newOrder.Surname, newOrder.Phone, newOrder.Location, accepted, date, newOrder.Status, newOrder.Paid)
	if err != nil {
		_ = tx.Rollback()
		return 0, err
	}

	id, err := result.LastInsertId()
	if err != nil {
		_ = tx.Rollback()
		return 0, err
	}
	newOrder.ID = int(id)

	err = s.UpdateOrderContents(tx, newOrder)
	if err != nil {
		_ = tx.Rollback()
		return 0, err
	}

	err = tx.Commit()
	log.Printf("INSERT order id=%d name=%q status=%q", newOrder.ID, newOrder.Name, newOrder.Status)
	return newOrder.ID, err
}