package platform

import (
	"encoding/json"
	"net/http"
	"sort"
	"time"
)

func (s *service) moveSubgraphMembers(w http.ResponseWriter, r *http.Request, project, account string) error {
	if r.Method != http.MethodPost {
		reject(w, 405, "method_not_allowed")
		return nil
	}
	if !acceptsCanvasV2(r) {
		reject(w, 409, "canvas_schema_upgrade_required")
		return nil
	}
	frame, key := r.PathValue("frame"), canvasIdempotencyKey(r)
	if !canvasID.MatchString(frame) || !uuidSlugPattern.MatchString(key) {
		reject(w, 400, "invalid_subgraph_request")
		return nil
	}
	var input struct {
		Source    string                        `json:"source_board_id"`
		Target    string                        `json:"target_board_id"`
		Nodes     []string                      `json:"node_ids"`
		Expected  map[string]int64              `json:"expected_versions"`
		Positions map[string]memberDropPosition `json:"positions,omitempty"`
	}
	if !decode(w, r, &input) {
		return nil
	}
	if !uuidSlugPattern.MatchString(input.Source) || !uuidSlugPattern.MatchString(input.Target) || input.Source == input.Target || len(input.Nodes) == 0 || len(input.Nodes) > 500 {
		reject(w, 400, "invalid_subgraph_request")
		return nil
	}
	for _, node := range input.Nodes {
		if !canvasID.MatchString(node) {
			reject(w, 400, "invalid_subgraph_request")
			return nil
		}
	}
	if !validMemberDropPositions(input.Nodes, input.Positions) {
		reject(w, 400, "invalid_subgraph_request")
		return nil
	}
	if len(input.Expected) == 0 {
		reject(w, 428, "version_required")
		return nil
	}
	workspace, parent := r.PathValue("workspace"), r.PathValue("material")
	tx, err := s.db.BeginTx(r.Context(), nil)
	if err != nil {
		return err
	}
	defer tx.Rollback()
	_, role, err := lockMaterial(r.Context(), tx, project, workspace, parent, account)
	if err != nil {
		return err
	}
	if role == "viewer" {
		reject(w, 403, "forbidden")
		return nil
	}
	action := "move_members/" + frame
	hash := payloadDigest(input)
	done, err := transactionRetry(w, r, tx, project, account, parent, action, key, hash)
	if err != nil {
		return err
	}
	if done {
		return nil
	}
	var associated string
	err = tx.QueryRowContext(r.Context(), `SELECT child_board_id::text FROM canvas_subgraphs WHERE project=$1 AND workspace_id=$2 AND parent_board_id=$3 AND frame_id=$4 AND archived_at IS NULL`, project, workspace, parent, frame).Scan(&associated)
	if err != nil {
		return err
	}
	if input.Source != associated && input.Target != associated {
		reject(w, 409, "ownership_conflict")
		return nil
	}
	participants := map[string]bool{parent: true, input.Source: true, input.Target: true}
	for _, board := range []string{input.Source, input.Target} {
		if board == parent {
			continue
		}
		relation, err := readSubgraphRelation(r, tx, project, workspace, board)
		if err != nil {
			return err
		}
		if relation.Parent != parent || relation.Archived {
			reject(w, 409, "ownership_conflict")
			return nil
		}
	}
	sourceSnapshot, err := loadCanvas(r, tx, project, workspace, input.Source)
	if err != nil {
		return err
	}
	sourceNodes := canvasNodeData(sourceSnapshot.Document)
	changes := []subgraphRelationChange{}
	for _, node := range input.Nodes {
		data := sourceNodes[node]
		if data == nil {
			reject(w, 409, "ownership_conflict")
			return nil
		}
		sub, _ := data["subgraph"].(map[string]any)
		child, _ := sub["boardId"].(string)
		if child == "" {
			continue
		}
		relation, err := readSubgraphRelation(r, tx, project, workspace, child)
		if err != nil {
			return err
		}
		if relation.Parent != input.Source || relation.Frame != node || relation.Archived {
			reject(w, 409, "ownership_conflict")
			return nil
		}
		if child == input.Target {
			reject(w, 409, "subgraph_cycle")
			return nil
		}
		after := relation
		after.Parent = input.Target
		changes = append(changes, subgraphRelationChange{Before: relation, After: after})
		rows, err := tx.QueryContext(r.Context(), `WITH RECURSIVE descendants(id,depth) AS(SELECT $3::uuid,0 UNION ALL SELECT s.child_board_id,d.depth+1 FROM descendants d JOIN canvas_subgraphs s ON s.project=$1 AND s.workspace_id=$2 AND s.parent_board_id=d.id AND s.archived_at IS NULL WHERE d.depth<8) SELECT id::text FROM descendants`, project, workspace, child)
		if err != nil {
			return err
		}
		for rows.Next() {
			var id string
			if err = rows.Scan(&id); err != nil {
				break
			}
			if id == input.Target {
				rows.Close()
				reject(w, 409, "subgraph_cycle")
				return nil
			}
			participants[id] = true
		}
		if err == nil {
			err = rows.Err()
		}
		rows.Close()
		if err != nil {
			return err
		}
	}
	parentSnapshot, err := loadCanvas(r, tx, project, workspace, parent)
	if err != nil {
		return err
	}
	repair, err := planAncestorPortRepair(r, tx, project, workspace, parent, input.Source, account, input.Nodes, parentSnapshot.Document)
	if err != nil {
		return err
	}
	if repair != nil {
		participants[repair.Ancestor] = true
	}
	if len(input.Expected) != len(participants) {
		reject(w, 428, "version_required")
		return nil
	}
	ids := []string{}
	for id := range participants {
		ids = append(ids, id)
	}
	sort.Strings(ids)
	snapshots := map[string]canvasSnapshot{}
	before := []canvasSnapshot{}
	for _, id := range ids {
		expected, exists := input.Expected[id]
		if !exists {
			reject(w, 428, "version_required")
			return nil
		}
		_, role, err := lockMaterial(r.Context(), tx, project, workspace, id, account)
		if err != nil {
			return err
		}
		if role == "viewer" {
			reject(w, 403, "forbidden")
			return nil
		}
		snapshot, err := loadCanvas(r, tx, project, workspace, id)
		if err != nil {
			return err
		}
		if snapshot.Version != expected {
			reject(w, 412, "version_conflict")
			return nil
		}
		snapshots[id] = snapshot
		before = append(before, snapshot)
	}
	raw := map[string]json.RawMessage{parent: snapshots[parent].Document, input.Source: snapshots[input.Source].Document, input.Target: snapshots[input.Target].Document}
	if input.Positions != nil {
		positioned, err := positionMemberDrop(raw[input.Source], input.Positions)
		if err != nil {
			reject(w, 409, "ownership_conflict")
			return nil
		}
		raw[input.Source] = positioned
	}
	moved, err := moveMembersDocuments(parent, input.Source, input.Target, input.Nodes, raw)
	if err != nil {
		if err == errGraphOwnership {
			reject(w, 409, "ownership_conflict")
		} else {
			reject(w, 413, "graph_limit_exceeded")
		}
		return nil
	}
	if repair != nil {
		moved[repair.Ancestor] = snapshots[repair.Ancestor].Document
		if err = applyAncestorPortRepair(repair, parent, input.Target, moved); err != nil {
			return err
		}
	}
	for _, change := range changes {
		if err = writeSubgraphRelation(r, tx, project, workspace, change.After); err != nil {
			return err
		}
	}
	updated := []canvasSnapshot{}
	versions := map[string]int64{}
	for _, id := range ids {
		snapshot := snapshots[id]
		if document, exists := moved[id]; exists {
			snapshot.Document = document
		}
		snapshot.Version++
		if err = s.saveCanvas(r, tx, project, workspace, snapshot); err != nil {
			return err
		}
		updated = append(updated, snapshot)
		versions[id] = snapshot.Version
		snapshots[id] = snapshot
	}
	var id string
	var receiptExpiry time.Time
	err = tx.QueryRowContext(r.Context(), `SELECT gen_random_uuid()::text,now()+interval '7 days'`).Scan(&id, &receiptExpiry)
	if err != nil {
		return err
	}
	result := response{"transaction_id": id, "parent": snapshots[parent], "snapshots": updated, "undo_receipt": response{"transaction_id": id, "valid_for_seconds": 604800, "expires_at": receiptExpiry}}
	encoded, _ := json.Marshal(result)
	beforeJSON, _ := json.Marshal(before)
	versionsJSON, _ := json.Marshal(versions)
	changesJSON, _ := json.Marshal(changes)
	_, err = tx.ExecContext(r.Context(), `INSERT INTO canvas_transactions(project,workspace_id,board_id,id,account_id,action,idempotency_key,payload_hash,response_status,response_body,before_state,after_versions,relation_changes) VALUES($1,$2,$3,$4,$5,$6,$7,$8,200,$9,$10,$11,$12)`, project, workspace, parent, id, account, action, key, hash, encoded, beforeJSON, versionsJSON, changesJSON)
	if err != nil {
		return err
	}
	if err = tx.Commit(); err != nil {
		return err
	}
	setVersion(w, versions[parent])
	reply(w, 200, result)
	return nil
}