<?php

namespace App\Http\Controllers\Admin;


use App\AuditTrail;
use App\CostPrice;
use App\Country;
use App\Currency;
use App\DataTables\AdminEsmeDataTable;
use App\DataTables\CountryNetworkDataTable;
use App\DataTables\NetworkCostPriceDataTable;
use App\DataTables\SettingCountryDataTable;
use App\DataTables\SettingCurrenciesDataTable;
use App\EsmeNetwork;
use App\Http\Controllers\Controller;
use App\Network;
use App\Setting;
use Carbon\Carbon;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\DB;


class SettingController extends Controller
{
    public function new_country_network($country_id) {
        $record = Country::findOrFail($country_id);
        return view('admin.setting.new_network', ['record' => $record]);
    }

    public function post_country_network(Request $request, $country_id) {
         $this->validate($request, [
            'network_name' => 'required|max:20',
            'registered_name' => 'required|max:100',
            'code' => 'required|numeric',
            'sms_price' => 'required|numeric',
            'prefixes' => 'required'
        ]);

        $country = Country::findOrfail($country_id);
        $user = $request->user();
        $inputs = [
            'full_name' => $request['registered_name'],
            'nice_name' => $request['network_name'],
            'code' => $request['code'],
            'sms_price' => $request['sms_price'],
            'prefix' => $request['prefixes']
        ];
        $existing = $country->networks()->where('nice_name', $inputs['nice_name'])->first();
        if($existing) {
            return redirect()->back()->withInput()->withErrors(array('name' => 'This record alreday exists!'));
        }
        $country->networks()->create($inputs);

        //update audit_trail
        AuditTrail::create([
            'user_id' => $user->id,
            'username' => $user->username,
            'date' => Carbon::now()->toDateTimeString(),
            'activity' => $user->name.' added a new network '.$inputs['nice_name'].' to '.$country->name
        ]);

        $request->session()->flash('success', $inputs['nice_name'].' was successfully been added to '.$country->name);
        return redirect()->route('admin.setting.countries.networks', ['country_id'=>$country_id]);
    }

    public function edit_country_network($country_id, $id) {
        $record = Country::findOrFail($country_id)->networks()->findOrfail($id);
        return view('admin.setting.edit_network', ['record' => $record]);
    }

    public function update_country_network(Request $request, $country_id, $id) {
        $this->validate($request, [
            'network_name' => 'required|max:20',
            'registered_name' => 'required|max:100',
            'code' => 'required|numeric',
            'sms_price' => 'required|numeric',
            'prefixes' => 'required'
        ]);

        $country = Country::findOrfail($country_id);
        $current = $country->networks()->findOrFail($id);
        $user = $request->user();
        $inputs = [
            'full_name' => $request['registered_name'],
            'nice_name' => $request['network_name'],
            'code' => $request['code'],
            'sms_price' => $request['sms_price'],
            'prefix' => $request['prefixes']
        ];
        $existing = $country->networks()
                ->where('nice_name', $inputs['nice_name'])
                ->where('id', '!=', $id)
                ->first();
        if($existing) {
            return redirect()->back()->withInput()->withErrors(array('name' => 'This record alreday exists!'));
        }
        $current->update($inputs);

        //update audit_trail
        AuditTrail::create([
            'user_id' => $user->id,
            'username' => $user->username,
            'date' => Carbon::now()->toDateTimeString(),
            'activity' => $user->name.' updated an existing network '.$inputs['nice_name'].' in '.$country->name
        ]);

        $request->session()->flash('success', $inputs['nice_name'].' was successfully been updated ');
        return redirect()->route('admin.setting.countries.networks', ['country_id'=>$country_id]);
    }

    public function delete_country_network($country_id, $id) {
        $country = Country::findOrfail($country_id);
        $current = $country->networks()->findOrFail($id);
        $current->delete();

        session()->flash('success', 'The network was successfully deleted!');
        return redirect()->route('admin.setting.countries.networks', ['country_id'=>$country_id]);
    }

    public function get_setting_countries(SettingCountryDataTable $dataTable) {
        return $dataTable->render('admin.setting.countries');
    }

    public function get_setting_currencies(SettingCurrenciesDataTable $dataTable) {
        return $dataTable->render('admin.setting.currency');
    }

    public function new_currency() {
        return view('admin.setting.new_currency');
    }

    public function post_currency(Request $request) {
        $this->validate($request, [
            'name' => 'required|unique:currencies,name',
            'abbr' => 'required|unique:currencies,abbr',
        ]);
        $inputs = $request->all();
        $user = $request->user();

        Currency::create($inputs);

        //update audit_trail
        AuditTrail::create([
            'user_id' => $user->id,
            'username' => $user->username,
            'date' => Carbon::now()->toDateTimeString(),
            'activity' => $user->name.' added a currency '.$inputs['name']
        ]);

        $request->session()->flash('success', 'The currency '.$inputs['name'].' was successfully added!');
        return redirect()->route('admin.setting.currencies');
    }

    public function edit_currency($id) {
        $currency = Currency::findOrFail($id);
        return view('admin.setting.edit_currency', ['record'=>$currency]);
    }

    public function update_currency(Request $request, $id) {
        //validate request
        $this->validate($request, [
            'name' => 'required|unique:currencies,name,'.$id,
            'abbr' => 'required|unique:currencies,abbr,'.$id,
        ]);

        $inputs = $request->all();
        $user = $request->user();
        $currentRecord = Currency::findOrFail($id);

        $currentRecord->fill($inputs);
        $currentRecord->save();

        //update audit_trail
        AuditTrail::create([
            'user_id' => $user->id,
            'username' => $user->username,
            'date' => Carbon::now()->toDateTimeString(),
            'activity' => $user->name.' updated an existing currency to '.$inputs['name']
        ]);

        $request->session()->flash('success', 'The currency has been successfully modified!');
        return redirect()->route('admin.setting.currencies');
    }

    public function delete_currency($id) {
        $record = Currency::findOrFail($id);
        $record->delete();

        session()->flash('success', 'The currency was successfully been deleted!');
        return redirect()->back();
    }

    public function new_country() {
        return view('admin.setting.new_country');
    }

    public function post_country(Request $request) {
        $this->validate($request, [
            'name' => 'required'
        ]);
        $inputs = $request->all();
        $user = $request->user();

        $existing = Country::where('name', $inputs['name'])->first();
        if($existing) {
            return redirect()->back()->withInput()->withErrors(array('name' => 'The name already exists!'));
        }
        Country::create($inputs);

        //update audit_trail
        AuditTrail::create([
            'user_id' => $user->id,
            'username' => $user->username,
            'date' => Carbon::now()->toDateTimeString(),
            'activity' => $user->name.' added a country '.$inputs['name']
        ]);

        $request->session()->flash('success', 'The country '.$inputs['name'].' was successfully created!');
        return redirect()->route('admin.setting.countries');
    }

    public function edit_country($id) {
        $country = Country::findOrFail($id);
        return view('admin.setting.edit_country', ['record'=>$country]);
    }

    public function update_country(Request $request, $id) {
        //validate request
        $this->validate($request, [
            'name' => 'required'
        ]);

        $inputs = $request->all();
        $user = $request->user();
        $currentRecord = Country::findOrFail($id);

        $existing = Country::where([
            ['name', '=', $inputs['name']],
            ['id', '!=', $id]
        ])->first();
        if($existing) {
            return redirect()->back()->withInput()->withErrors(array('name' => 'The name already exists!'));
        }

        $currentRecord->fill($inputs);
        $currentRecord->save();

        //update audit_trail
        AuditTrail::create([
            'user_id' => $user->id,
            'username' => $user->username,
            'date' => Carbon::now()->toDateTimeString(),
            'activity' => $user->name.' updated an existing country to '.$inputs['name']
        ]);

        $request->session()->flash('success', 'The country has been successfully modified!');
        return redirect()->route('admin.setting.countries');
    }

    public function delete_country($id) {
        $country = Country::findOrFail($id);
        $country->networks()->delete();
        $country->delete();

        session()->flash('success', 'The country was successfully been deleted!');
        return redirect()->back();
    }

    public function get_country_network(CountryNetworkDataTable $dataTable, $country_id) {
        $record = Country::findOrFail($country_id);
        return $dataTable->with_country($country_id)
                         ->render('admin.setting.country_networks', [
                             'record' => $record
                         ]);
    }

    // network cost price list
    public function network_cost_price_list(NetworkCostPriceDataTable $dataTable)
    {
        return $dataTable->render('admin.setting.cost_price_list');
    }

    // network cost price edit
    public function network_cost_price_edit($user, Request $request)
    {
        if (strtoupper($request->method()) == 'POST')
        {
            $data       = $request->request;
            $record     = \App\CostPrice::where('user_id', $data->get('user'))->where('country_id', $data->get('country'))->first();
            $record     = $record != null ? $record : new CostPrice();
            $sdata      = [];
            $networks   = $data->get('network');

            foreach ($networks as $ntwk)
                $sdata[] = ['network' => $ntwk, 'price' => $data->get('price')];

            $record->country_id = $data->get('country');
            $record->user_id    = $data->get('user');
            $record->data       = \GuzzleHttp\json_encode($sdata);
            $record->price      = $data->get('price');
            $record->save();

            return redirect()->route('admin.setting.cost.price.list');
        }
        else
        {
            $ctx    = \App\Country::get();
            $record = DB::table('cost_prices')->where('user_id', '=', $user)->first();

            $networks = [];

            if ($record != null)
            {
                $data = json_decode($record->data, true);

                foreach ($data as $dt)
                {
                    if (array_key_exists('network', $dt))
                        if (!in_array($dt['network'], $networks))
                            $networks[] = $dt['network'];
                }
            }

            if (count($record) <= 0) $record = (object) ['price' => 0.00, 'user_id' => $user, 'country_id' => null];

            return view('admin.setting.cost_price_edit', [
                'data' => $record,
                'countries' => $ctx,
                'networks' => json_encode($networks)
            ]);
        }
    }

    // network cost price delete
    public function network_cost_price_del()
    {

    }

    public function get_esme_list(AdminEsmeDataTable $dataTable) {
        return $dataTable->render('admin.esme.index');
    }

    public function esme_networks($username) {
        $user = DB::connection('kannel')->table('unit_prices')->where('username', $username)->first();
        if(empty($user))
            abort(404, 'User Not Found!');
        $data = [];
        foreach (Network::with('country')
                     ->orderBy('country_id')
                     ->orderBy('nice_name')
                     ->get( ) as $record) {
            $existing = EsmeNetwork::where([
                ['username', '=', $username],
                ['network_id', '=', $record->id],
                ['country_id', '=', $record->country_id]
            ])->orderBy('created_at', 'desc')->first();
            $data[] = [
                'id' => $record->id,
                'full_name' => $record->full_name,
                'nice_name' => $record->nice_name,
                'code' => $record->code,
                'country_id' => $record->country_id,
                'country' => $record->country->name,
                'prefix' => $record->prefix,
                'sms_price' => empty($existing) ? $user->unit_price : $existing->sms_price
            ];
        }
        return view('admin.esme.esme_networks', ['data'=>$data, 'user'=>$user]);
    }

    public function update_esme_network(Request $request, $username, $id) {
        $this->validate($request, [
            'sms_price' => 'required|numeric'
        ]);

        $user = DB::connection('kannel')->table('unit_prices')->where('username', $username)->first();
        if(empty($user))
            abort(404, 'User Not Found!');
        $global_network = Network::findOrFail($id);
//        $user_network = EsmeNetwork::where('username', $username)
//            ->where('network_id', $global_network->id)
//            ->where('country_id', $global_network->country_id)
//            ->orderBy('created_at', 'desc')
//            ->first();

        $new_price = (float)$request['sms_price'];
        if(!empty($new_price)) {
            if((float)$new_price !== (float)$user->unit_price) {
                EsmeNetwork::create([
                    'username' => $username,
                    'network_id'  => $global_network->id,
                    'country_id' => $global_network->country_id,
                    'sms_price' => $new_price
                ]);
            }
        } else {
            return redirect()->back()->withInput()->withErrors(array('error' => 'The network price is invalid'));
        }

        $request->session()->flash('success', 'The esme network price was successfully updated!');
        return redirect()->route('admin.setting.esme.networks', ['username'=>$user->username]);
    }

    public function edit_esme_network($username, $id) {
        $user = DB::connection('kannel')->table('unit_prices')->where('username', $username)->first();
        if(empty($user))
            abort(404, 'User Not Found!');
        $global_network = Network::findOrFail($id);
        $user_network = EsmeNetwork::where('username', $username)
            ->where('network_id', $global_network->id)
            ->where('country_id', $global_network->country_id)
            ->orderBy('created_at', 'desc')
            ->first();
        $record = [
            'id' => $global_network->id,
            'full_name' => $global_network->full_name,
            'nice_name' => $global_network->nice_name,
            'code' => $global_network->code,
            'country_id' => $global_network->country_id,
            'country' => $global_network->country->name,
            'prefix' => $global_network->prefix,
            'sms_price' => empty($user_network) ? $user->unit_price : $user_network->sms_price
        ];

        return view('admin.esme.edit_esme_network', [
            'user' => $user,
            'record' => $record
        ]);

    }

    // find networks by country
    public function get_networks_by_country($country)
    {
        $data = [];

        if ($country != null)
        {
            $data = DB::table('networks')->where('country_id', '=', $country)->orderby('nice_name', 'asc')->get();
        }

        $response = ['data' => $data];
        return response($response)->header('Content-Type', 'text/json');
    }

    // operational setting
    public function operational_setting(Request $request)
    {
        $user       = Auth::user();
        $setting    = \App\Setting::where('user_id', $user->id)->first();

        if (strtoupper($request->method()) == 'POST')
        {
            $data       = $request->request;
            $setting    = \App\Setting::where('user_id', $user->id)->first();
            $setting    = $setting != null ? $setting : new Setting();

            if ($data != null)
            {
                $setting->user_id       = $user->id;
                $setting->electricity   = $data->get('electricity');
                $setting->water         = $data->get('water');
                $setting->nhil          = $data->get('nhil');
                $setting->vat           = $data->get('vat');
                $setting->others        = $data->get('others');
                $setting->cst           = $data->get('cst');

                $setting->save();
            }
        }
        else
        {
            if ($setting == null)
            {
                $setting = new Setting();
                $setting->user_id       = $user->id;
                $setting->electricity   = 0.00;
                $setting->water         = 0.00;
                $setting->nhil          = 0.00;
                $setting->vat           = 0.00;
                $setting->others        = 0.00;
                $setting->cst           = 0;
            }
        }

        return view('admin.setting.operational_setting', [
            'data' => $setting
        ]);
    }
}