// Without IoC
Customer customer = new Customer();
FullName fullName = new FullName();
customer.setFullName(fullName); // Manual wiring

// With IoC
Customer customer = context.getBean(Customer.class); // Spring creates and wires everything

ApplicationContext context = new ClassPathXmlApplicationContext("banking-app.xml");
Customer customer = context.getBean("customer", Customer.class);

ApplicationContext context = new ClassPathXmlApplicationContext("banking-app.xml");
UserDataDao userDataDao = context.getBean(UserDataDao.class);

@Component
@PropertySource("classpath:application.properties")
public class UserDataDao {
    @Autowired
    private RestClient restClient;
    
    @Value("${userUrl}")
    private String userDataUrl;
}

ApplicationContext context = new AnnotationConfigApplicationContext(TransactionConfigurer.class);
TransactionService service = context.getBean(TransactionService.class);

@Configuration
@ComponentScan(basePackages = "sh.surge.kunal.banking")
@Import({DirectDebitConfigurer.class, ExternalDebitConfigurer.class})
public class TransactionConfigurer {
}

public class CustomerApp {
    public static void main(String[] args) {
        Faker faker = new Faker();
        Logger logger = Logger.getLogger("CustomerApp");
        
        // Load context from XML file
        ApplicationContext context = new ClassPathXmlApplicationContext("banking-app.xml");
        
        // IoC: Spring creates the object
        FullName fullName1 = context.getBean("fullName", FullName.class);
        
        // DI: Set properties (Faker generates random data)
        fullName1.setFirstName(faker.name().firstName());
        fullName1.setLastName(faker.name().lastName());
        
        logger.info("Full Name: " + fullName1);
        
        // Get Customer bean (with dependencies already injected by Spring)
        Customer customer1 = context.getBean("customer", Customer.class);
        customer1.setAccountNo(faker.number().numberBetween(10000000, 99999999));
        
        logger.info("Customer: " + customer1);
    }
}

public class UserApp {
    public static void main(String[] args) {
        Logger logger = Logger.getLogger("UserApp");
        
        // XML loads the context BUT enables component scanning
        ApplicationContext context = new ClassPathXmlApplicationContext("banking-app.xml");
        
        // Spring finds UserDataDao via @Component annotation
        UserDataDao userDataDao = context.getBean(UserDataDao.class);
        
        // Display user data fetched from REST API
        userDataDao.getUserData().entrySet().stream()
            .map(entry -> entry.getKey() + " : " + entry.getValue())
            .forEach(logger::info);
    }
}

@Component  // Marks this class as a Spring-managed bean
@PropertySource("classpath:application.properties")  // Loads external properties
public class UserDataDao {
    
    @Autowired  // Spring injects RestClient automatically
    private RestClient restClient;
    
    @Value("${userUrl}")  // Injects value from application.properties
    private String userDataUrl;
    
    private Map<String, String> userDataMap;
    
    public Map<String, String> getUserData() {
        userDataMap = new HashMap<>();
        
        // Fetch data from external API using injected RestClient
        String response = restClient.get()
            .uri(userDataUrl)  // URL from properties file
            .retrieve()
            .body(String.class);
        
        // Parse JSON response
        JSONArray usersArray = new JSONArray(response);
        for (int i = 0; i < usersArray.length(); i++) {
            String username = usersArray.getJSONObject(i).getString("name");
            String email = usersArray.getJSONObject(i).getString("email");
            userDataMap.put(username, email);
        }
        
        return userDataMap;
    }
}

public class TransactionApp {
    public static void main(String[] args) {
        Logger logger = Logger.getLogger("TransactionApp");
        
        // Zero XML! Load configuration from Java class
        ApplicationContext context = 
            new AnnotationConfigApplicationContext(TransactionConfigurer.class);
        
        // Get service with all dependencies injected
        TransactionService transactionService = context.getBean(TransactionService.class);
        
        // Process transactions
        logger.info("Direct Debit: " + transactionService.processDirectDebit());
        logger.info("External Debit: " + transactionService.processExternalDebit());
    }
}

@Configuration  // Marks this as a configuration class (replaces XML)
@ComponentScan(basePackages = "sh.surge.kunal.banking")  // Scans for components
@Import({DirectDebitConfigurer.class, ExternalDebitConfigurer.class})  // Imports other configs
public class TransactionConfigurer {
    // This class doesn't need methods - it just enables component scanning
    // Actual beans are defined in imported configurers or found via @Component
}

@Configuration
public class DirectDebitConfigurer {
    
    @Bean(name = "directDebitTransaction")  // Creates a Spring-managed bean
    public Transaction getDirectDebitTransaction() {
        return new DirectDebitTransaction();  // Factory method
    }
}

@Configuration
public class ExternalDebitConfigurer {
    
    @Bean(name = "externalDebitTransaction")
    public Transaction getExternalDebitTransaction() {
        return new ExternalDebitTransaction();
    }
}

@Configuration
public class RestConfigurer {
    
    @Bean  // Creates RestClient bean for HTTP calls
    public RestClient restClient() {
        return RestClient.create();  // Spring WebClient factory method
    }
}

@Service  // Specialized @Component for service layer
@Data  // Lombok: generates getters, setters, toString, etc.
public class TransactionService {
    
    private final Transaction directDebitTransaction;
    private final Transaction externalDebitTransaction;
    private Faker faker;
    
    // Constructor Injection (recommended over field injection)
    public TransactionService(
        @Qualifier("directDebitTransaction") Transaction directDebitTransaction,
        @Qualifier("externalDebitTransaction") Transaction externalDebitTransaction
    ) {
        this.directDebitTransaction = directDebitTransaction;
        this.externalDebitTransaction = externalDebitTransaction;
        this.faker = new Faker();
    }
    
    public Transaction processDirectDebit() {
        DirectDebitTransaction transaction = (DirectDebitTransaction) this.directDebitTransaction;
        
        // Use Faker to generate realistic test data
        transaction.setSenderName(faker.name().fullName());
        transaction.setReceiverName(faker.name().fullName());
        transaction.setTransactionDate(faker.date().birthday()
            .toInstant().atZone(ZoneId.systemDefault()).toLocalDate());
        transaction.setAmount(faker.number().numberBetween(10000, 100000));
        transaction.setPaymentDate(faker.date().birthday()
            .toInstant().atZone(ZoneId.systemDefault()).toLocalDate());
        
        return transaction;
    }
    
    public Transaction processExternalDebit() {
        ExternalDebitTransaction transaction = (ExternalDebitTransaction) this.externalDebitTransaction;
        
        transaction.setSenderName(faker.name().fullName());
        transaction.setReceiverName(faker.name().fullName());
        transaction.setTransactionDate(faker.date().birthday()
            .toInstant().atZone(ZoneId.systemDefault()).toLocalDate());
        transaction.setAmount(faker.number().numberBetween(10000, 100000));
        transaction.setBranchAddress(faker.address().fullAddress());
        transaction.setBranchCode(faker.number().digits(5).toString());
        transaction.setBranchPostalCode(faker.address().zipCode());
        transaction.setBranchName(faker.company().name());
        
        return transaction;
    }
}

@Data  // Generates getters, setters, toString, equals, hashCode
@AllArgsConstructor  // Constructor with all fields
@NoArgsConstructor   // No-arg constructor (required by Spring)
@Component  // Makes this a Spring-managed bean
public class Customer {
    protected long accountNo;
    
    @Autowired
    protected FullName fullName;
    
    @Autowired
    @Qualifier("homeAddress")  // Specify which Address bean to inject
    protected Address address;
    
    @Autowired
    @Qualifier("savingsAccount")
    protected Account account;
    
    protected long contactNo;
    protected String email;
    protected String password;
}

@Data
@AllArgsConstructor
@NoArgsConstructor
@EqualsAndHashCode(callSuper = false)  // Uses parent class fields in equals/hashCode
@ToString(callSuper = true)  // Includes parent class toString
public class DirectDebitTransaction extends Transaction {
    private LocalDate paymentDate;
}

@Data
@AllArgsConstructor
@NoArgsConstructor
@EqualsAndHashCode(callSuper = false)
@ToString(callSuper = true)
public class ExternalDebitTransaction extends Transaction {
    private String branchName;
    private String branchAddress;
    private String branchPostalCode;
    private String branchCode;
}