Configurable Security with OPC UA Java Integration

I need a Java application that connects to an OPC UA server and handles read and write operations using OPC TCP port and server IP address. The solution should manage security features like encryption and authentication. It should support both polling and Change of Value (CoV) methods for data acquisition. Additionally, the code must be able to discover available nodes, read data, and write data back to the server.

### Key Requirements:
1. **OPC UA Server Connection**:
- Establish a connection to the OPC UA server using OPC TCP port and server IP address.
- Ensure security features like encryption and authentication are supported and configurable.

2. **Reading Data**:
- Implement a mechanism to discover available nodes on the server.
- Allow reading data from specific OPC UA nodes using polling or CoV (Change of Value) methods.

3. **Writing Data**:
- Implement functionality to write data back to specific nodes on the OPC UA server.

4. **Security**:
- Support encryption and security policies such as Basic256Sha256 or Basic128Rsa15.
- Include runtime configurable security options as well as hardcoded settings for testing purposes.

5. **Code Quality**:
- The code must be clean, well-documented, and efficient.
- Provide detailed logging for connection status, read/write operations, and error handling.

### Milestones:
To ensure the project is progressing properly, the following milestones should be met:

1. **Milestone 1**:
- Basic connection to the OPC UA server.
- Verify successful connection using logs.

2. **Milestone 2**:
- Implement and test reading from specific OPC UA nodes.
- Provide logs showing successful data read from a specific node path.

3. **Milestone 3**:
- Implement security features (encryption, user authentication).
- Test security configuration and connection status.

4. **Milestone 4**:
- Implement and test writing data to specific nodes on the OPC UA server.
- Provide logs demonstrating successful data writes.

5. **Milestone 5**:
- Implement CoV and polling methods for data reading.
- Test and verify both mechanisms work as expected.

### Example OPC UA Node Path:
For testing, you can use a node path like:
```
ns=2;s=Machine1.TemperatureSensor.Value
```
Where:
- `ns=2`: Namespace index.
- `s=Machine1.TemperatureSensor.Value`: Node ID representing the machine's temperature sensor value.

### Testing Strategy:
To verify that the solution works as expected, we will use the following testing process:

1. **Logs for Verification**:
- Ensure the program generates detailed logs for each operation (connection, read, write).
- These logs will allow me to verify if the code is connecting properly, reading/writing data, and handling errors.

2. **Test Server for Development**:
- If you don’t have access to a specific server, you can use an open OPC UA test server for development and testing, such as Prosys OPC UA Simulation Server or Eclipse Milo.
- I will provide the correct OPC TCP port and server IP address or use a public test server.

3. **Test Case**:
- **Connection Test**: Establish a connection to the OPC UA server using the provided server details (IP, port, security settings).
- **Data Reading Test**: Read a specific data point from the server using the given node path (e.g., `ns=2;s=Machine1.TemperatureSensor.Value`).
- **Data Writing Test**: Write a value back to a writable node and confirm it is updated on the server.
- **Security Test**: Implement and test security features, such as encryption and authentication.

4. **Manual Testing**:
- I will use an OPC UA client like **UaExpert** to independently verify the data being read/written by your application.
- Ensure that the read/write operations reflect correctly on the server and match the values viewed through the client.

5. **Screenshots/Screen Recordings**:
- Provide screenshots or screen recordings demonstrating the program connecting, reading data, and writing data to the OPC UA server.
- This will serve as visual confirmation that the code works as expected.

6. **Unit Tests**:
- Please include unit tests for read/write functions. This will allow me to run tests on my side to ensure the functions behave as intended.

### Deliverables:
1. **Java Code**: Complete Java code for OPC UA connection, data reading, and writing operations.
2. **Security Implementation**: Support for security features (encryption, authentication), with clear instructions on how to configure them.
3. **Logging**: Detailed logs for connection status, read/write success, and error handling.
4. **Documentation**: Documentation explaining how to run the program, configure the connection (server IP, port, security), and test the application.
5. **Executable**: A working executable or script that I can run to test the solution with an OPC UA server.
6. **Instructions**: Step-by-step instructions for connecting to the server and running the program.