using FlowAPI.Application.DTOs.Sync;
using FlowAPI.Application.Interfaces;
using FlowAPI.Domain.Entities;

namespace FlowAPI.Application.Services
{
    public class SyncService : ISyncService
    {
        private readonly ITaskNodeRepository _nodeRepo;
        private readonly IEdgeRepository _edgeRepo;

        public SyncService(ITaskNodeRepository nodeRepo, IEdgeRepository edgeRepo)
        {
            _nodeRepo = nodeRepo;
            _edgeRepo = edgeRepo;
        }

        public async Task<SyncResponseDto> SyncChangesAsync(Guid userId, SyncRequestDto request)
        {
            try
            {
                // 1. Process Node Deletions
                foreach (var id in request.DeletedNodeIds)
                {
                    await _nodeRepo.DeleteAsync(id);
                }

                // 2. Process Edge Deletions
                foreach (var id in request.DeletedEdgeIds)
                {
                    await _edgeRepo.DeleteAsync(id);
                }

                // 3. Process New Nodes
                foreach (var dto in request.NewNodes)
                {
                    var node = new TaskNode
                    {
                        Id = Guid.NewGuid(),
                        GraphId = dto.GraphId,
                        Label = dto.Label,
                        PosX = dto.PosX,
                        PosY = dto.PosY,
                        State = dto.State
                    };
                    await _nodeRepo.CreateAsync(node);
                }

                // 4. Process Updated Nodes
                foreach (var dto in request.UpdatedNodes)
                {
                    var node = await _nodeRepo.GetByIdAsync(dto.Id);
                    if (node != null)
                    {
                        if (dto.Label != null) node.Label = dto.Label;
                        if (dto.PosX.HasValue) node.PosX = dto.PosX.Value;
                        if (dto.PosY.HasValue) node.PosY = dto.PosY.Value;
                        if (dto.State.HasValue) node.State = dto.State.Value;
                        await _nodeRepo.UpdateAsync(node);
                    }
                }

                // 5. Process New Edges
                foreach (var dto in request.NewEdges)
                {
                    var edge = new Edge
                    {
                        Id = Guid.NewGuid(),
                        GraphId = dto.GraphId,
                        FromNodeId = dto.FromNodeId,
                        ToNodeId = dto.ToNodeId,
                        Condition = dto.Condition
                    };
                    await _edgeRepo.CreateAsync(edge);
                }

                return new SyncResponseDto
                {
                    Success = true,
                    Message = "Synchronization completed successfully.",
                    ServerTime = DateTime.UtcNow
                };
            }
            catch (Exception ex)
            {
                return new SyncResponseDto
                {
                    Success = false,
                    Message = $"Sync failed: {ex.Message}",
                    ServerTime = DateTime.UtcNow
                };
            }
        }
    }
}