using GrpcShared.DTO;
using GrpcShared.DTO.Db;
using GrpcShared.Interfaces;
using IdentityProvider.Models;
using Microsoft.Extensions.Options;
using MongoDB.Driver;

namespace IdentityProvider.Services
{
    public class IdentityService : IIdentityService
    {
        private readonly IMongoCollection<UserModel> _userCollection;
        private readonly IMongoCollection<TrackModel> _trackCollection;
        public IdentityService(IOptions<SpotifyDbConfig> spotifyDbConfig)
        {
            var mongoClient = new MongoClient(spotifyDbConfig.Value.ConnectionString);
            var mongoDbContext = mongoClient.GetDatabase(spotifyDbConfig.Value.DatabaseName);
            _userCollection = mongoDbContext.GetCollection<UserModel>(spotifyDbConfig.Value.UserCollection);
            _trackCollection = mongoDbContext.GetCollection<TrackModel>(spotifyDbConfig.Value.TracksCollection);
        }


        public async Task<List<UserResponse>> ListUsersAsync(VoidMessage msg)
        {
            List<UserModel> users = await _userCollection.Find(_ => true).ToListAsync();
            //map users to match the grpc response
            var usersRes = users.Select(u => new UserResponse
            {
                Id = u.Id,
                Token = u.Token
            }).ToList();
            return usersRes;
        }
        public async Task<UserResponse> GetTokenByIdAsync(DbRequestMessage request)
        {
            UserModel user = await _userCollection.Find(u => u.Id == request.Id).FirstOrDefaultAsync();
            return new UserResponse
            {
                Id = user.Id,
                Token = user.Token
            };
        }
        public async Task<TrackResponse> GetTrackByUserAsync(DbRequestMessage request)
        {
            TrackModel track = await _trackCollection.Find(t => t.UserId == request.Id).FirstOrDefaultAsync();
            return new TrackResponse
            {
                Id = track.Id,
                Album = track.Album,
                Artist = track.Artist,
                Title = track.Title,
                TrackId = track.TrackId
            };
        }
        public async Task<VoidMessage> SaveTrackAsync(SaveTrackRequest track)
        {

            TrackModel trackModel = new()
            {
                Title = track.Title,
                Album = track.Album,
                Artist = track.Artist,
                UserId = track.UserId,
                TrackId = track.TrackId
            };
            //first check if there's already a song in the db, if yes, update the row
            var song = await _trackCollection.Find(x => x.UserId == track.UserId).AnyAsync();

            if (song) await _trackCollection.ReplaceOneAsync(x => x.UserId == track.UserId, trackModel);

            else await _trackCollection.InsertOneAsync(trackModel);

            return new VoidMessage();


        }
        public async Task<VoidMessage> SaveUserAsync(UserResponse userRequest)
        {
            bool user = await _userCollection.Find(x => x.Id == userRequest.Id).AnyAsync();
            if (!user) await _userCollection.InsertOneAsync(new UserModel
            {
                Token = userRequest.Token
            });
            return new VoidMessage();
        }
        public async Task<VoidMessage> DeleteTrackAsync(DbRequestMessage request)
        {
            await _trackCollection.DeleteOneAsync(x => x.Id == request.Id);
            return new VoidMessage();
        }
        public async Task<VoidMessage> DeleteUserAsync(DbRequestMessage userRequest)
        {
            //check if user exists
            bool user = await _userCollection.Find(x => x.Id == userRequest.Id).AnyAsync();
            //delete track related to him
            if (user)
            {
                await _trackCollection.DeleteManyAsync(x => x.UserId == userRequest.Id);
                //delete user
                await _userCollection.DeleteOneAsync(x => x.Id == userRequest.Id);
            }
            return new VoidMessage();
        }



    }
}