import torch
import torch.nn as nn
from data import LMDBDataLoader
from torch.optim import Adam
from models.schnet import SchNet
from utils import train, evaluate, ForceRMSELoss
from data import LMDBDataLoader, _STD_ENERGY, _STD_FORCE_SCALE

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

root = '/path/to/lmdb/dir'
batch_size = 128
num_workers = 16
stage = '1st'
total_traj = True
SubsetOnly=True

loader = LMDBDataLoader(root=root, batch_size=batch_size, num_workers=num_workers, stage=stage, total_traj=total_traj, SubsetOnly=SubsetOnly)

train_set = loader.train_loader()
val_set = loader.val_loader()
test_set = loader.test_loader()

hidden_channels = 128
num_gaussians = 128
num_filters = 128

batch_size = 128
num_interactions = 4
cutoff = 4.5

model = SchNet(num_gaussians=num_gaussians, num_filters=num_filters, hidden_channels=hidden_channels, num_interactions=num_interactions, cutoff=cutoff)
model = model.to(device)

max_epochs = 100

params = [param for _, param in model.named_parameters() if param.requires_grad]
lr = 5e-4
weight_decay = 0.0

optimizer = Adam([{'params' : params},], lr=lr, weight_decay=weight_decay)
criterion_energy = nn.L1Loss()

criterion_force = ForceRMSELoss()

for epoch in range(max_epochs):
     
    train_energy_loss, train_force_loss = train(model, device, train_set, optimizer, criterion_energy, criterion_force)

    val_energy_loss, val_force_loss = evaluate(model, device, val_set, criterion_energy, criterion_force)

    print(f"#IN#Epoch {epoch + 1}, Train Energy Loss: {train_energy_loss * _STD_ENERGY:.5f}, Val Energy Loss: {val_energy_loss * _STD_ENERGY:.5f}, Train Force Loss: {train_force_loss * _STD_FORCE_SCALE:.5f}, Val Force Loss: {val_force_loss * _STD_FORCE_SCALE:.5f}")

test_energy_loss, test_force_loss = evaluate(model, device, test_set, criterion_energy, criterion_force)

print(f'Test Energy Loss: {test_energy_loss * _STD_ENERGY:.5f}, Test Force Loss: {test_force_loss * _STD_FORCE_SCALE:.5f}')