using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WpfApp1TRC20.Data;

namespace WpfApp1TRC20.Services
{
    public class DataService : IDataService
    {
        private readonly AppDbContext _context;
        private readonly ITronService _tronService;

        public DataService(AppDbContext context, ITronService tronService)
        {
            _context = context;
            _tronService = tronService;
        }

        public async Task<List<TokenInfo>> GetTokensAsync()
        {
            return await _context.Tokens.ToListAsync();
        }

        public async Task<List<WalletAccount>> GetWalletsAsync()
        {
            var wallets = await _context.Wallets.ToListAsync();

            // Update TRX balances
            foreach (var wallet in wallets)
            {
                try
                {
                    wallet.TrxBalance = await _tronService.GetTrxBalanceAsync(wallet.Address);
                }
                catch
                {
                    // Continue if balance check fails
                }
            }

            return wallets;
        }

        public async Task<List<TransactionRecord>> GetTransactionsAsync()
        {
            return await _context.Transactions
                .OrderByDescending(t => t.Timestamp)
                .ToListAsync();
        }

        public async Task<TokenInfo> SaveTokenAsync(TokenInfo token)
        {
            if (token.Id == 0)
            {
                _context.Tokens.Add(token);
            }
            else
            {
                _context.Tokens.Update(token);
            }

            await _context.SaveChangesAsync();
            return token;
        }

        public async Task<WalletAccount> SaveWalletAsync(WalletAccount wallet)
        {
            if (wallet.Id == 0)
            {
                _context.Wallets.Add(wallet);
            }
            else
            {
                _context.Wallets.Update(wallet);
            }

            await _context.SaveChangesAsync();
            return wallet;
        }

        public async Task<TransactionRecord> SaveTransactionAsync(TransactionRecord transaction)
        {
            if (transaction.Id == 0)
            {
                _context.Transactions.Add(transaction);
            }
            else
            {
                _context.Transactions.Update(transaction);
            }

            await _context.SaveChangesAsync();
            return transaction;
        }

        public async Task DeleteTokenAsync(int tokenId)
        {
            var token = await _context.Tokens.FindAsync(tokenId);
            if (token != null)
            {
                _context.Tokens.Remove(token);
                await _context.SaveChangesAsync();
            }
        }

        public async Task DeleteWalletAsync(int walletId)
        {
            var wallet = await _context.Wallets.FindAsync(walletId);
            if (wallet != null)
            {
                _context.Wallets.Remove(wallet);
                await _context.SaveChangesAsync();
            }
        }

        public async Task<List<TokenBalance>> GetTokenBalancesAsync(string walletAddress)
        {
            var tokens = await _context.Tokens.Where(t => t.Status == TokenStatus.Active).ToListAsync();
            var balances = new List<TokenBalance>();

            foreach (var token in tokens)
            {
                try
                {
                    var balance = await _tronService.GetTokenBalanceAsync(token.ContractAddress, walletAddress);
                    balances.Add(new TokenBalance
                    {
                        TokenSymbol = token.Symbol,
                        ContractAddress = token.ContractAddress,
                        Balance = balance,
                        Decimals = token.Decimals,
                        WalletAddress = walletAddress
                    });
                }
                catch
                {
                    // Continue if balance check fails
                }
            }

            return balances;
        }
    }
}