package store

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

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

func (s *Store) GetSpecialCakeTags(specialCakeID int) ([]models.Tag, error) {
	rows, err := s.db.Query(`
		select t.id, t.name from tag t
		join special_cake_tag sct on sct.tag = t.id
		where sct.special_cake = ?
		order by t.name
	`, specialCakeID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()

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

func (s *Store) GetSpecialCakes(orderID int) ([]models.SpecialCake, error) {
	rows, err := s.db.Query("select id, customer_order, name, price, size, shape, flavour, notes from special_cake where customer_order = ?;", orderID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	var out []models.SpecialCake
	for rows.Next() {
		var sc models.SpecialCake
		var price int
		if err := rows.Scan(&sc.ID, &sc.OrderID, &sc.Name, &price, &sc.Size, &sc.Shape, &sc.Flavour, &sc.Notes); err != nil {
			return nil, err
		}
		sc.Price = models.Price(price)
		tags, err := s.GetSpecialCakeTags(sc.ID)
		if err != nil {
			return nil, err
		}
		sc.Tags = tags
		out = append(out, sc)
	}
	return out, rows.Err()
}

func (s *Store) saveSpecialCakeTags(tx *sql.Tx, specialCakeID int, tagIDs []int) error {
	if _, err := tx.Exec("delete from special_cake_tag where special_cake = ?;", specialCakeID); err != nil {
		return err
	}
	for _, tid := range tagIDs {
		if _, err := tx.Exec("insert or ignore into special_cake_tag(special_cake, tag) values (?, ?);", specialCakeID, tid); err != nil {
			return err
		}
	}
	return nil
}

func (s *Store) GetSpecialCakesInRange(from, to time.Time) ([]models.SpecialCakeWithOrder, error) {
	start, end := dateRangeParams(from, to)
	rows, err := s.db.Query(`
		SELECT sc.id, sc.customer_order, sc.name, sc.price, sc.size, sc.shape, sc.flavour, sc.notes,
		       co.name, co.surname, co.delivery_date
		FROM special_cake sc
		JOIN customer_order co ON sc.customer_order = co.id
		WHERE co.status != 'picked_up' AND co.delivery_date >= ? AND co.delivery_date <= ?
		ORDER BY co.delivery_date
	`, start, end)
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	var out []models.SpecialCakeWithOrder
	for rows.Next() {
		var sw models.SpecialCakeWithOrder
		var price int
		var deliveryDate string
		if err := rows.Scan(&sw.ID, &sw.OrderID, &sw.Name, &price, &sw.Size, &sw.Shape, &sw.Flavour, &sw.Notes,
			&sw.ClientName, &sw.ClientSurname, &deliveryDate); err != nil {
			return nil, err
		}
		sw.Price = models.Price(price)
		sw.OrderDate, err = time.Parse(config.DateTimeFormat, deliveryDate)
		if err != nil {
			return nil, err
		}
		sw.Tags, err = s.GetSpecialCakeTags(sw.ID)
		if err != nil {
			return nil, err
		}
		out = append(out, sw)
	}
	return out, rows.Err()
}

func (s *Store) SaveSpecialCakes(tx *sql.Tx, orderID int, cakes []models.SpecialCake) error {
	if _, err := tx.Exec("delete from special_cake where customer_order = ?;", orderID); err != nil {
		return err
	}
	if len(cakes) == 0 {
		return nil
	}
	q := "insert into special_cake(customer_order, name, price, size, shape, flavour, notes) values (?, ?, ?, ?, ?, ?, ?);"
	for _, sc := range cakes {
		log.Printf("INSERT special_cake order=%d name=%q price=%d", orderID, sc.Name, sc.Price)
		res, err := tx.Exec(q, orderID, sc.Name, int(sc.Price), sc.Size, sc.Shape, sc.Flavour, sc.Notes)
		if err != nil {
			return err
		}
		id, err := res.LastInsertId()
		if err != nil {
			return err
		}
		if err := s.saveSpecialCakeTags(tx, int(id), tagIDs(sc.Tags)); err != nil {
			return err
		}
	}
	return nil
}