/*
 * Author:      Bhaskar S
 * Date:        01/27/2018
 * Description: CSS style for the Auto vehicle dealer-buyer Ethereum web application
 */

body {
    font-family: 'Roboto', serif;
}

table {
    border: 0px;
    width: 100%;
}

tr {
    margin: 5px;
    width: 100%;
}

h3 {
    font-size: 18px;
    font-weight: bold;
    text-align: center;
}

p, label {
    margin: 12px;
    font-size: 12px;
    font-weight: bold;
    display: inline-block;
}

hr {
    text-align: center;
    width: 20%;
}

input {
    border-radius: 4px;
    font-size: 12px;
    display: inline-block;
}

button {
    border-radius: 4px;
    font-size: 14px;
    font-weight: bold;
}

.centeralign {
    text-align: center;
}

#title {
    background-color: #f2d7d5;
    border: 2px solid #c0392b;
    height: 5%;
    width: 100%;
    font-size: 20px;
    font-weight: bold;
    text-align: center;
}

#buyer {
    background-color: #d5f5e3;
    border: 1px solid #239b56;
    margin: 5px;
    width: 50%;
}
#buyer hr {
    color: #239b56;

}
#buyer input {
    border: 1px solid #239b56;
}

#dealer {
    background-color: #d6eaf8;
    border: 1px solid #2471a3;
    margin: 5px;
    width: 50%;
}
#dealer hr {
    color: #2471a3;
}
#dealer input {
    border: 1px solid #2471a3;
}

#events {
    background-color: #fcf3cf;
    border: 1px solid #f1c40f;
    margin: 5px;
}
#events hr {
    color: #f1c40f;
}
#events p {
    display: block;
}

/*
 * Author:      Bhaskar S
 * Date:        01/27/2018
 * Description: Javascript data and functions for the Auto vehicle dealer-buyer Ethereum
 *              web application
 */

const evt = document.getElementById('evt_list');
const cin = document.getElementById('contract');
const pin = document.getElementById('payment');

const ast = '2px solid #c0392b';
const dst = '2px solid #000000';

const xhr = new XMLHttpRequest();

window.onload = init();

var data = undefined;
var data2 = undefined;

/*
 * This function makes an ajax call to the url '/init' to get the values for:
 * the dealer account balance, the buyer account balance, the buyer address,
 * and the vehicle cost.
 * 
 * On success, the appropriate dom elements on the page are updated
 */
function init() {
    cin.addEventListener('click' , contract);
    pin.addEventListener('click' , payment);
    toggle(false); // Enable dealer button
    xhr.open('GET', '/init', true);
    xhr.onreadystatechange = function() {
        if (xhr.readyState === 4) {
            if (xhr.status === 200) {
                // log(xhr.responseText);

                data = JSON.parse(xhr.responseText);

                document.getElementById('dbal').innerText = data.dealer_balance;
                document.getElementById('baddr').value = data.buyer;
                document.getElementById('vcost').value = data.cost;
                document.getElementById('vamt').value = data.cost;
                document.getElementById('bbal').innerText = data.buyer_balance;

                log('UI: Application successfully initialied');
            } else {
                log(`ERROR: status code ${xhr.status}`);
            }
        }
    };
    xhr.send();
}

/*
 * This function will ensure that only one button is active at any point in
 * time - either the button to deploy a contract on the dealer column or the
 * payment button on the buyer column once the contract has been deployed.
 */
function toggle(state) {
    cin.disabled = state;
    cin.style.border = (state ? dst : ast);
    cin.style.opacity = (state ? 0.5 : 1);
    pin.disabled = !state;
    pin.style.border = (!state ? dst : ast);
    pin.style.opacity = (!state ? 0.5 : 1);
}

/*
 * This function logs messages on the bottom part of the screen in the Event
 * Messages box.
 */
function log(msg) {
    let dt = new Date();
    let pnode = document.createElement('p');
    pnode.textContent = '[' + dt.toString() + '] ' + msg;
    evt.appendChild(pnode);
}

/*
 * This function makes an ajax call to the url '/contract' to deploy the
 * Vehicle2 contract. If the contract is successfully deployed, the server
 * returns the deployed contract address.
 * 
 * On sucess, the appropriate dom element on the page is updated
 */
function contract() {
    xhr.open('POST', '/contract', true);
    xhr.setRequestHeader("Content-type", "application/json");
    xhr.onreadystatechange = function() {
        if (xhr.readyState === 4) {
            if (xhr.status === 200) {
                // log(xhr.responseText);

                data2 = JSON.parse(xhr.responseText);

                document.getElementById('caddr').value = data2.contract_address;

                toggle(true); // Enable buyer button

                log('UI: Contract successfully deployed');
            } else {
                log(`ERROR: status code ${xhr.status}`);
            }
        }
    };
    xhr.send(JSON.stringify(data));
}

/*
 * This function makes an ajax call to the url '/payment' to invoke the
 * deployed Vehicle2 contract method buyVehicle. On successful invocation,
 * the server returns the current dealer account balance, the current
 * buyer account balance, and a list of events that have been emitted
 * by the deployed contract.
 * 
 * On sucess, the appropriate dom elements in the page are updated
 */
function payment() {
    xhr.open('POST', '/payment', true);
    xhr.setRequestHeader("Content-type", "application/json");
    xhr.onreadystatechange = function() {
        if (xhr.readyState === 4) {
            if (xhr.status === 200) {
                // log(xhr.responseText);

                let data3 = JSON.parse(xhr.responseText);

                document.getElementById('dbal').innerText = data3.dealer_balance;
                document.getElementById('bbal').innerText = data3.buyer_balance;
                document.getElementById('caddr').value = '';

                data3.events.forEach(event => {
                    log(`NODE: Event ${JSON.stringify(event)}`);
                });

                toggle(false); // Enable dealer button

                log('UI: Payment successfully executed');
            } else {
                log(`ERROR: status code ${xhr.status}`);
            }
        }
    };
    xhr.send(JSON.stringify(data2));
}

<!DOCTYPE html>
<html lang="en">
    <head>
        <meta charset='UTF-8' />
        <title>Auto Vehicle Dealer-Buyer Interaction</title>
        <link rel="stylesheet" type="text/css" href="http://fonts.googleapis.com/css?family=Roboto">
        <link href="style.css" rel="stylesheet">
    </head>
    <body>
        <div id='title'>Auto Vehicle Dealer-Buyer Interaction</div>
        <br/>
        <table>
            <tr>
                <td id='dealer'>
                    <div>
                        <h3>Dealer</h3>
                        <hr />
                        <br />
                        <p>Dealer Balance:</p><label id='dbal' type='text'>0</label>
                        <br />
                        <p>Buyer Address:</p><input id='baddr' size=50 type='text' readonly />
                        <br />
                        <p>Vehicle Cost:</p><input id='vcost' type='text' readonly />
                        <br />
                        <br />
                        <div class='centeralign' id='one'>
                            <button id='contract'>Set Contract</button>
                        </div>
                    </div>
                </td>
                <td id='buyer'>
                    <div>
                        <h3>Buyer</h3>
                        <hr />
                        <br />
                        <p>Buyer Balance:</p><label id='bbal' type='text'>0</label>
                        <br />
                        <p>Contract Address:</p><input id='caddr' size=50 type='text' readonly />
                        <br />
                        <p>Amount:</p><input id='vamt' type='text' readonly />
                        <br />
                        <br />
                        <div class='centeralign' id='two'>
                            <button id='payment'>Make Payment</button>
                        </div>
                    </div>
                </td>
            </tr>
            <tr>
                <td colspan="2">
                    <div id='events'>
                        <h3>Event Messages</h3>
                        <hr />
                        <br />
                        <div id='evt_list'></div>
                    </div>
                </td>
            </tr>
        </table>
        <script type="text/javascript" src="vehicle.js"></script>
    </body>
</html>

pragma solidity ^0.4.15;

/*
 * This AmountOwed contract implements a common function modifier to check the value of tranfer
 * satisfies the amount owed to dealer
 */

contract AmountOwed {
    // Modifiers can be used to change the behaviour of any function in a contract, such as checking
    // a condition prior to executing the function. Modifiers are inheritable properties of contracts
    // and may be overridden by derived contracts
    modifier validate(uint amt) {
        require(msg.value >= amt);
        _; // Function body
    }
}

/*
 * A Vehicle instance is first created in the Ethereum blockchain by the dealer.
 * Once the payment is received, the dealer transfers ownership to the buyer.
 */

contract Vehicle2 is AmountOwed {
    enum DealStatus { Open, Closed }
    
    uint _flag;
    uint _vin;
    uint _cost;
    address _owner;
    address _dealer;
    DealStatus _status;
    
    event Bought(uint vin, uint cost);
    
    function getFlag() public view returns (uint) {
        return _flag;
    }
    
    function getVin() public view returns (uint) {
        return _vin;
    }
    
    function getCost() public view returns (uint) {
        return _cost;
    }
    
    function getOwner() public view returns (address) {
        return _owner;
    }
    
    function getDealer() public view returns (address) {
        return _dealer;
    }
    
    function getStatus() public view returns (DealStatus) {
        return _status;
    }
    
    // The keyword 'payable' is important for accepting ethers from the buyer
    function buyVehicle() public payable validate(_cost) {
        _flag = 1;
        // Only the assigned owner can close the deal
        if (msg.sender == _owner) {
            _flag = 2;
            _status = DealStatus.Closed;
            _dealer.transfer(_cost);
            Bought(_vin, _cost);
        }
    }
    
    function Vehicle2(uint vin, uint cost, address buyer) public {
        _flag = 0;
        _vin = vin;
        _cost = cost;
        _owner = buyer;
        _dealer = msg.sender;
        _status = DealStatus.Open;
    }
}

/*
 * Author:      Bhaskar S
 * Date:        01/27/2018
 * Description: Node.JS and Express based server for the Auto vehicle dealer-buyer Ethereum
 *              web application
 */

var fs = require('fs');
var express = require('express');
var bodyparser = require('body-parser');
var Web3 = require('web3');
var solc = require('solc');
var util = require('util');

let vin = '1234567890';
let cost = 1000000000000000000;
let gas = 1000000;
let abi = undefined;
let bin = undefined;
let web3 = undefined;

/*
 * This function prepares the server by compiling the Vehicle2 solidity contract
 * source code using the solc npm module. On successful compile, extracts the
 * ABI definition and the bytecode. In addition, initializes a web3 connection
 * to the private ethereum network.
 */
function setUp() {
    let source = fs.readFileSync('../src/Vehicle2.sol', 'UTF-8');
    let compiled = solc.compile(source);

    bin = compiled.contracts[':Vehicle2'].bytecode;

    util.log(`>>>>> setup - Bytecode: ${bin}`);
    util.log(`>>>>> setup - ABI: ${compiled.contracts[':Vehicle2'].interface}`);
    
    abi = JSON.parse(compiled.contracts[':Vehicle2'].interface);

    web3 = new Web3(new Web3.providers.HttpProvider('http://localhost:8081'));

    util.log('>>>>> setup - Completed !!!')
}

/*
 * This function handles the ajax call to the url '/init'. It uses the web3
 * connection to fetch all the 4 accounts in our private ethereum network
 * and selects the buyer (2nd) and dealer (3rd) account addresses. Next,
 * makes a call to fetch the balances for the buyer and dealer accounts.
 * 
 * Returns the results in the json format:
 * 
 * {
 *     vin: <vin number>,
 *     cost: <vehicle cost>,
 *     buyer: <buyer account address>
 *     dealer: <dealer account address>
 *     buyer_balance: <buyer account balance in ethers>,
 *     dealer_balance: <dealer account balance in ethers>
 * }
 */
function initApi(response) {
    let data = {
        vin: vin,
        cost: 1,
        buyer: undefined,
        dealer: undefined,
        buyer_balance: undefined,
        dealer_balance: undefined
    };

    web3.eth.getAccounts()
    .then(accounts => {
        util.log(`>>>>> initApi - Accounts: ${accounts}`);

        data.buyer = accounts[1];
        data.dealer = accounts[2];

        util.log(`>>>>> initApi - Buyer address: ${data.buyer}`);

        return web3.eth.getBalance(data.buyer);
    })
    .then(balance1 => {
        util.log(`>>>>> initApi - Buyer balance: ${web3.utils.fromWei(balance1, 'ether')}`);

        data.buyer_balance = balance1;

        return web3.eth.getBalance(data.dealer);
    })
    .then(balance2 => {
        util.log(`>>>>> initApi - Dealer balance: ${web3.utils.fromWei(balance2, 'ether')}`);

        data.dealer_balance = balance2;

        response.json(data);
    });
}

/*
 * This function handles the ajax call to the url '/contract'. Since the dealer
 * is responsible for deploying the contract, uses the web3 connection to unlock
 * the dealer account and then deploys the contract code to the private Ethereum
 * network. Once the contract is mined and deployed, extracts the deployed contract
 * address.
 * 
 * Returns the results in the json format:
 * 
 * {
 *     vin: <vin number>,
 *     cost: <vehicle cost>,
 *     buyer: <buyer account address>
 *     dealer: <dealer account address>
 *     contract_address: <address of the deployed contract>
 * }
 */
function contractApi(request, response) {
    let contract = new web3.eth.Contract(abi);

    let data = {
        vin: request.body.vin,
        cost: request.body.cost,
        buyer: request.body.buyer,
        dealer: request.body.dealer,
        contract_address: undefined
    };

    util.log(`>>>>> contractApi - Unlocking ${request.body.dealer} account`);

    web3.eth.personal.unlockAccount(request.body.dealer, 'dealer')
    .then(result => {
        util.log(`>>>>> contractApi - Is dealer account unlocked ? ${result}`);
        util.log('>>>>> contractApi - Ready to deploy Vehicle2 contract');

        contract.deploy({
            data: '0x'+bin,
            arguments: [request.body.vin, cost, request.body.buyer]
        })
        .send({
            from: request.body.dealer,
            gas: gas
        })
        .on('receipt', receipt => {
            util.log(`>>>>> contractApi - Contract sucessfully deployed @ address: ${receipt.contractAddress}`);

            data.contract_address = receipt.contractAddress;

            response.json(data);
        });
    }, error => {
        util.log(`***** contractApi - Dealer account unlock error - ${error}`);
    });
}

/*
 * This function handles the ajax call to the url '/payment'. Since the buyer is
 * the entity invoking the contract, uses the web3 connection to unlock the buyer
 * account and then invoke the buyVehicle method on the depoloyed contract. Once
 * the contract method is mined and executed, extracts the balances for the buyer
 * and dealer accounts as well as the emitted events.
 * 
 * Returns the results in the json format:
 * 
 * {
 *     events: <array of emitted events>,
 *     buyer_balance: <buyer account balance in ethers>,
 *     dealer_balance: <dealer account balance in ethers>
 * }
 */
function paymentApi(request, response) {
    let contract = new web3.eth.Contract(abi);

    util.log(`>>>>> paymentApi - Contract address: ${request.body.contract_address}`);

    contract.options.address = request.body.contract_address;    

    util.log(`>>>>> paymentApi - Unlocking ${request.body.buyer} account`);

    web3.eth.personal.unlockAccount(request.body.buyer, 'buyer')
    .then(result => {
        util.log(`>>>>> paymentApi - Is buyer account unlocked ? ${result}`);
        util.log('>>>>> paymentApi - Ready to invoke buyVehicle() method');

        contract.methods.buyVehicle()
        .send({
            from: request.body.buyer,
            value: cost,
            gas: gas
        })
        .on('receipt', receipt => {
            util.log(`>>>>> paymentApi - Contract method buyVehicle() successfully invoked: ${receipt}`);
    
            let data = { 
                events: [], 
                buyer_balance: 0, 
                dealer_balance: 0 
            };

            contract.getPastEvents('Bought', {
                fromBlock: 0,
                toBlock: 'latest'
            })
            .then(events => {
                events.forEach(event => {
                    data.events.push(event.returnValues);
                });
                
                util.log(`>>>>> paymentApi - List of events - ${JSON.stringify(data.events)}`);
    
                return web3.eth.getBalance(request.body.buyer);
            })
            .then(balance1 => {
                util.log(`>>>>> paymentApi - Buyer balance: ${web3.utils.fromWei(balance1, 'ether')}`);
    
                data.buyer_balance = web3.utils.fromWei(balance1, 'ether');
    
                return web3.eth.getBalance(request.body.dealer);
            })
            .then(balance2 => {
                util.log(`>>>>> paymentApi - Dealer balance: ${web3.utils.fromWei(balance2, 'ether')}`);

                data.dealer_balance = web3.utils.fromWei(balance2, 'ether');

                response.json(data);
            })
        })
    }, error => {
        util.log(`***** paymentApi - Buyer unlock error - ${error}`);
    });
}

/*
 * ----- Start of The main server code -----
 */

setUp();

var app = express();

app.use(bodyparser.json());

app.use(function(req, res, next) {
    util.log(`Request => url: ${req.url}, method: ${req.method}`);
    next();
});

app.use(express.static('./static'));

app.get('/init', function(req, res) {
    initApi(res);
});

app.post('/contract', function(req, res) {
    contractApi(req, res);
});

app.post('/payment', function(req, res) {
    paymentApi(req, res);
});

app.listen(9001);

util.log('-> Express server @localhost:9001');