package com.carpics2p0.capture20.activity.core;

import static com.carpics2p0.capture20.activity.core.HomeActivity.EMPTY_STRING;
import static com.carpics2p0.capture20.activity.core.HomeActivity.IMAGES_RESULT_CODE;
import static com.carpics2p0.capture20.activity.core.HomeActivity.SCANNER_RESULT_CODE;
import static com.carpics2p0.capture20.activity.core.HomeActivity.VIN;

import android.Manifest;
import android.content.ContentValues;
import android.content.DialogInterface;
import android.content.SharedPreferences;
import android.content.pm.PackageManager;
import android.content.res.ColorStateList;
import android.database.Cursor;
import android.databinding.DataBindingUtil;
import android.os.Parcelable;
import android.support.annotation.NonNull;
import android.support.v4.app.ActivityCompat;
import android.support.v4.content.ContextCompat;
import android.text.Editable;
import android.text.TextWatcher;
import android.view.View.OnClickListener;
import android.view.inputmethod.InputMethodManager;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemSelectedListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.ProgressBar;
import android.widget.Toast;
import com.carpics2p0.capture20.R;

import android.content.Context;
import android.content.Intent;
import android.support.v7.app.ActionBar;
import android.support.v7.app.AlertDialog;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.widget.ArrayAdapter;
import android.widget.ImageView;
import android.widget.Spinner;
import android.widget.TextView;

import com.carpics2p0.capture20.activity.apicalls.ApiCall;
import com.carpics2p0.capture20.activity.apicalls.ApiCallback;
import com.carpics2p0.capture20.activity.apiobjects.ApiResponse;
import com.carpics2p0.capture20.activity.apiobjects.Data;
import com.carpics2p0.capture20.activity.apiobjects.Dealer;
import com.carpics2p0.capture20.activity.apiobjects.FilterStencil;
import com.carpics2p0.capture20.activity.apiobjects.Stencil;
import com.carpics2p0.capture20.activity.data.DbController;
import com.carpics2p0.capture20.activity.data.OrdersContract.OrderEntry;
import com.carpics2p0.capture20.activity.data.StencilContract.StencilEntry;
import com.carpics2p0.capture20.activity.orderpackage.Order;
import com.carpics2p0.capture20.activity.orderpackage.OrderFactory;
import com.carpics2p0.capture20.activity.orderpackage.OrderImages;
import com.carpics2p0.capture20.activity.tips.WeatherSelectionActivity;
import com.carpics2p0.capture20.activity.utilities.CustomArray;
import com.carpics2p0.capture20.activity.vinscanning.ScannerActivity;
import com.carpics2p0.capture20.databinding.ActivityNewVehicleBinding;
import com.microsoft.appcenter.AppCenter;
import com.microsoft.appcenter.analytics.Analytics;
import com.microsoft.appcenter.crashes.Crashes;
import java.io.File;
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;

public class NewVehicleActivity extends AppCompatActivity implements View.OnClickListener {

  private static final String TAG = NewVehicleActivity.class.getSimpleName();

  private static final String PACKAGE_NAME = "com.carpics2p0.capture20.activity";

  private static final int REQUEST_CODE = 100;

  private static SharedPreferences sharedpreferences;

  private DbController dbController;

  private TextView saveBtn;

  private android.support.v7.app.ActionBar customActionBar;

  private List<Integer> allFields;

  private List<Integer> allSpinners;

  public static int imagesAdded;

  public static String username;

  private String dealerId;

  private int orderId;

  private boolean orderCreated;

  private ActivityNewVehicleBinding binding;

  private String token;

  private ArrayAdapter<String> interiorColorAdapter;

  private ArrayAdapter<String> conditionAdapter;

  private ArrayAdapter<String> yearAdapter;

  private ArrayAdapter<String> exteriorColorAdapter;

  private ArrayAdapter<String> dealerSelectionAdapter;

  private ApiResponse apiResponse;

  private String uniqueOrderApiId;

  private List<String> interiorColors;

  private String note;

  private boolean editMode;

  private boolean priorEditingAttachment;

  private Data editData;

  private boolean alreadyUploaded;

  private ProgressBar saveBtnProgress;

  private boolean deleteNote;

  private List<Dealer> dealers;

  private int selectedDealer;

  private List<String> dealersStencils;

  private List<Stencil> dealerStencilsObjects;

  private boolean photosButtonClicked;

  private boolean scanVinClicked;

  private WeakReference<Context> applicationContext;

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    orderCreated = false;
    setContentView(R.layout.activity_new_vehicle);
    AppCenter.start(getApplication(), "9a517ec0-b5b9-4306-ab40-4e6e01b94fb1",
        Analytics.class, Crashes.class);
    applicationContext = new WeakReference<Context>(this);
    binding = DataBindingUtil.setContentView(this, R.layout.activity_new_vehicle);
    dealers = this.getIntent().getParcelableArrayListExtra("dealers");
    selectedDealer = 0;
    dealersStencils = new ArrayList<>();
    checkIfEditing();
    attachViewsAndListeners();
    dataSetUp();
    inflateCustomActionBar();
    attachToken();
    vinScanner();
    newOrderListener();
    setVinListener();
    orderId = -1;
    checkEditing();
    attachListenerToSave();
    getStencilsReady();
    checkIfUploaded();
    AppCenter.start(getApplication(), "9a517ec0-b5b9-4306-ab40-4e6e01b94fb1",
        Analytics.class, Crashes.class);
  }

  public void checkIfEditing() {
    if (getIntent().getBooleanExtra(OrderDetail.EDIT_ORDER, false)) {
      editMode = true;
    }
  }

  public void getStencilsReady() {
    dealerStencilsObjects = new ArrayList<>();
    dealersStencils = new ArrayList<>();
    Cursor stencilsCursor = dbController.getStencils();
    Map<String, FilterStencil> filterStencilHashMap = new HashMap<>();
    while (stencilsCursor.moveToNext()) {
      FilterStencil filterStencil = new FilterStencil();
      String stencilId = String
          .valueOf(stencilsCursor
              .getString(stencilsCursor.getColumnIndex(StencilEntry.COLUMN_STENCIL_ID)));
      String templateImage = String
          .valueOf(stencilsCursor
              .getString(
                  stencilsCursor.getColumnIndex(StencilEntry.COLUMN_TEMPLATE_IMAGE_FILE_LOCATION)));
      String exampleImage = String
          .valueOf(stencilsCursor
              .getString(
                  stencilsCursor.getColumnIndex(StencilEntry.COLUMN_EXAMPLE_IMAGE_FILE_LOCATION)));
      filterStencil.setStencilId(stencilId);
      filterStencil.setTemplateImage(templateImage);
      filterStencil.setExampleImage(exampleImage);
      filterStencilHashMap.put(stencilId, filterStencil);
    }
    List<String> stencils = dealers.get(selectedDealer).getStencilIds();
    for (String dealerStencilId : stencils) {
      if (filterStencilHashMap.containsKey(dealerStencilId)) {
        FilterStencil filterStencil = filterStencilHashMap.get(dealerStencilId);
        if (filterStencil.getTemplateImage() != null && filterStencil.getExampleImage() != null) {
          dealersStencils.add(filterStencil.getStencilId());
        }
      }
    }
    if (dealersStencils.size() > 0) {
      binding.photosButton.setVisibility(View.VISIBLE);
    } else {
      binding.photosButton.setVisibility(View.GONE);
    }
    dealerStencilsObjects = dbController.getStencilsObjects(dealersStencils);
  }

  private void checkIfUploaded() {
    if (editMode) {
      if (OrderFactory.getOrderInstance(String.valueOf(orderId)).getOrderUploadStatus()
          .equals("UPLOADED")) {
        hide(binding.form);
        show(binding.alreadyUploaded);
        alreadyUploaded = true;
        binding.photosButton.setVisibility(View.GONE);
        binding.separator.setVisibility(View.GONE);
      }
    }
  }

  private void checkEditing() {
    if (getIntent().getBooleanExtra(OrderDetail.EDIT_ORDER, false)) {
      binding.deleteVehicle.setVisibility(View.VISIBLE);
      orderId = getIntent().getIntExtra(HomeActivity.ORDER_ID, -1);
      imagesAdded = OrderFactory.getOrderInstance(String.valueOf(orderId))
          .getImagesAdded();
      editData = new Data(
          OrderFactory.getOrderInstance(String.valueOf(orderId)).getDealership(),
          OrderFactory.getOrderInstance(String.valueOf(orderId)).getVinNumber(),
          OrderFactory.getOrderInstance(String.valueOf(orderId)).getStock(),
          OrderFactory.getOrderInstance(String.valueOf(orderId)).getVehicleYear(),
          OrderFactory.getOrderInstance(String.valueOf(orderId)).getMake(),
          OrderFactory.getOrderInstance(String.valueOf(orderId)).getModel(),
          OrderFactory.getOrderInstance(String.valueOf(orderId)).getVehicleCondition(),
          OrderFactory.getOrderInstance(String.valueOf(orderId)).getExteriorColor(),
          OrderFactory.getOrderInstance(String.valueOf(orderId)).getInteriorColor()
      );
      note = OrderFactory.getOrderInstance(String.valueOf(orderId)).getNote();
      if (note != null) {
        binding.noteText.setText(R.string.edit_note);
      }
      disableSaveBtn();
      editMode = true;
      priorEditingAttachment = true;
      attachFields(editData);
    } else {
      imagesAdded = 0;
    }
  }

  public void enableSaveBtn() {
    saveBtn.setEnabled(true);
    saveBtn.setTextColor(getResources().getColor(R.color.colorWhite));
  }

  public void disableSaveBtn() {
    saveBtn.setEnabled(false);
    saveBtn.setTextColor(getResources().getColor(R.color.colorDarkGrey));
  }

  private void attachListenerToSave() {
    TextWatcher textWatcher = new TextWatcher() {
      public void afterTextChanged(Editable editable) {
      }

      public void beforeTextChanged(CharSequence charSequence, int start, int count, int after) {
      }

      public void onTextChanged(CharSequence charSequence, int start, int before, int count) {
        if (priorEditingAttachment) {
          return;
        }
        if (editMode) {
          enableSaveBtn();
        } else {
          if ((checkFields() && checkSpinners())) {
            enableSaveBtn();
          } else {
            disableSaveBtn();
          }
        }
      }
    };

    OnItemSelectedListener itemSelectedListener = new OnItemSelectedListener() {
      @Override
      public void onItemSelected(AdapterView<?> parent, View view, int position, long id) {
        if (position != 0) {
          ((TextView) view).setTextColor(getResources().getColor(R.color.colorWhite));
          if ((checkFields() && checkSpinners())) {
            enableSaveBtn();
          } else {
            disableSaveBtn();
          }
        }
      }

      @Override
      public void onNothingSelected(AdapterView<?> parent) {

      }
    };

    OnItemSelectedListener dealerItemSelected = new OnItemSelectedListener() {
      @Override
      public void onItemSelected(AdapterView<?> parent, View view, int position, long id) {
        selectedDealer = position;
        getStencilsReady();
      }

      @Override
      public void onNothingSelected(AdapterView<?> parent) {

      }
    };

    binding.vin.addTextChangedListener(textWatcher);
    binding.stock.addTextChangedListener(textWatcher);
    binding.model.addTextChangedListener(textWatcher);
    binding.make.addTextChangedListener(textWatcher);
    if (priorEditingAttachment) {
      int dealerSelectionAdapterPosition = dealerSelectionAdapter
          .getPosition(editData.getDealerId());
      binding.dealerShipSpinner.setSelection(dealerSelectionAdapterPosition, false);
      int conditionAdapterPosition = conditionAdapter.getPosition(editData.getCondition());
      binding.conditionSpinner.setSelection(conditionAdapterPosition, false);
      if(binding.conditionSpinner.getSelectedView()!=null){
        ((TextView) binding.conditionSpinner.getSelectedView())
                .setTextColor(getResources().getColor(R.color.colorWhite));
      }


      int exColorAdapterPosition = exteriorColorAdapter.getPosition(editData.getExteriorColor());
      binding.exColorSpinner.setSelection(exColorAdapterPosition, false);
      if(binding.exColorSpinner.getSelectedView()!=null) {
        ((TextView) binding.exColorSpinner.getSelectedView())
                .setTextColor(getResources().getColor(R.color.colorWhite));
      }

      int interiorColorAdapterPosition = interiorColorAdapter
          .getPosition(editData.getInteriorColor());
      binding.intColorSpinner.setSelection(interiorColorAdapterPosition, false);
      if(binding.intColorSpinner.getSelectedView()!=null) {
        ((TextView) binding.intColorSpinner.getSelectedView())
                .setTextColor(getResources().getColor(R.color.colorWhite));
      }
      int yearAdapterPosition = yearAdapter
          .getPosition(editData.getYear());
      binding.yearSpinner.setSelection(yearAdapterPosition, false);
      ((TextView) binding.yearSpinner.getSelectedView())
          .setTextColor(getResources().getColor(R.color.colorWhite));
    } else {
      binding.conditionSpinner.setSelection(0, false);
      binding.exColorSpinner.setSelection(0, false);
      binding.intColorSpinner.setSelection(0, false);
      binding.yearSpinner.setSelection(0, false);
    }

    if (!editMode) {
      binding.dealerShipSpinner.setOnItemSelectedListener(dealerItemSelected);
    } else {
      binding.dealerShipSpinner.setEnabled(false);
    }
    binding.conditionSpinner.setOnItemSelectedListener(itemSelectedListener);
    binding.exColorSpinner.setOnItemSelectedListener(itemSelectedListener);
    binding.intColorSpinner.setOnItemSelectedListener(itemSelectedListener);
    binding.yearSpinner.setOnItemSelectedListener(itemSelectedListener);
    priorEditingAttachment = false;
  }

  public ApiCall newOrderListener() {
    return new ApiCall(applicationContext.get(), new ApiCallback<ApiResponse>() {
      @Override
      public void onCallFinished(ApiResponse apiResponse) {
        if (apiResponse != null) {
          uniqueOrderApiId = apiResponse.getData().getId();
          addOrdersFactory(orderId);
          if (editMode) {
            dbController.updateOrderId(orderId, username, getContentOfFields());
            Intent intent = new Intent();
            setResult(RESULT_OK, intent);
            finish();
          } else {
            if (orderCreated) {
              ContentValues cv = new ContentValues();
              cv.put(OrderEntry.COLUMN_UNIQUE_API_ID, apiResponse.getData().getId());
              dbController.updateOrderId(orderId, username, cv);
            } else {
              addOrderToDatabase();
            }
            hide(saveBtnProgress);
            show(saveBtn);
            finish();
          }
        }
      }
    });
  }

  public ApiCall getVinDecodeCall() {
    return new ApiCall(applicationContext.get(), new ApiCallback<ApiResponse>() {
      @Override
      public void onCallFinished(ApiResponse result) {
        binding.apiCallProgressBar.setVisibility(View.INVISIBLE);
        binding.smallScan.setVisibility(View.VISIBLE);
        binding.tvSearchCaption.setVisibility(View.VISIBLE);
        if (result == null) {
          showInvalidVinError();
        } else {
          apiResponse = result;
          attachApiInfo();
        }
      }
    });
  }

  public void getDealersCall() {
    new ApiCall(applicationContext.get(), new ApiCallback<ApiResponse>() {
      @Override
      public void onCallFinished(ApiResponse result) {
        if (result != null) {
          dealers = result.getDealers();
        }
      }
    }).getDealers(token);
  }

  public void setVinListener() {
    binding.vin.setOnFocusChangeListener(new View.OnFocusChangeListener() {
      @Override
      public void onFocusChange(View v, boolean hasFocus) {
        if (!hasFocus) {
          if (binding.vin.getText().length() > 0) {
            checkVinWithApi(binding.vin.getText().toString());
          }
        }
      }
    });
  }

  public void vinScanner() {
    binding.scanVin.setOnClickListener(new OnClickListener() {
      @Override
      public void onClick(View view) {
        scanVinClicked = true;
        if (ContextCompat.checkSelfPermission(applicationContext.get(), Manifest.permission.CAMERA)
            == PackageManager.PERMISSION_DENIED) {
          ActivityCompat
              .requestPermissions(NewVehicleActivity.this, new String[]{Manifest.permission.CAMERA},
                  REQUEST_CODE);
        } else {
          Intent scanVin = new Intent(applicationContext.get(), ScannerActivity.class);
          startActivityForResult(scanVin, SCANNER_RESULT_CODE);
        }
      }
    });
  }

  private void dataSetUp() {
    sharedpreferences = getSharedPreferences(PACKAGE_NAME, Context.MODE_PRIVATE);
    username = sharedpreferences.getString("username", "");
    dealerId = sharedpreferences.getString("dealerId", "");
    dbController = new DbController(applicationContext.get(), username);
  }

  @Override
  public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions,
      @NonNull int[] grantResults) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    if (requestCode == REQUEST_CODE) {

      if (grantResults[0] == PackageManager.PERMISSION_GRANTED) {
        if (scanVinClicked) {
          Intent scanVin = new Intent(applicationContext.get(), ScannerActivity.class);
          startActivityForResult(scanVin, SCANNER_RESULT_CODE);
        }
      } else {
        Toast.makeText(applicationContext.get(), "camera permission denied", Toast.LENGTH_LONG)
            .show();
      }
    }
  }

  @Override
  protected void onResume() {
    super.onResume();
    if (OrderFactory.getOrderInstance(String.valueOf(orderId)).getImagesAdded() > imagesAdded) {
      imagesAdded = OrderFactory.getOrderInstance(String.valueOf(orderId)).getImagesAdded();
      enableSaveBtn();
    }
    getDealersCall();
    if (imagesAdded > 0) {
      binding.vehiclePhotosText.setText(imagesAdded + "/25");
    } else {
      binding.vehiclePhotosText.setText("Start Shooting");
    }
  }

  @Override
  public void onBackPressed() {
    showDiscardChangedAlert();
  }

  public void showDiscardChangedAlert() {
    DialogInterface.OnClickListener dialogClickListener = new DialogInterface.OnClickListener() {
      @Override
      public void onClick(DialogInterface dialog, int which) {
        switch (which) {
          case DialogInterface.BUTTON_POSITIVE:
            if (!editMode) {
              deleteOrder(orderId);
            }
            finish();
            break;
          case DialogInterface.BUTTON_NEGATIVE:
            dialog.cancel();
            break;
        }
      }
    };
    AlertDialog.Builder builder;
    builder = new AlertDialog.Builder(applicationContext.get(), R.style.MyAlertDialogStyle);
    builder.setTitle("Discard changes").setMessage("are you sure?")
        .setPositiveButton(R.string.yes, dialogClickListener)
        .setNegativeButton(R.string.no, dialogClickListener).show();
  }

  public void deleteOrder(int orderId) {
    if (orderCreated) {
      deleteLocalOrder(orderId);
    }
  }

  public void attachViewsAndListeners() {
    binding.noteButton.setOnClickListener(this);
    binding.photosButton.setOnClickListener(this);
    binding.deleteVehicle.setOnClickListener(this);
    allFields = Arrays.asList(R.id.vin, R.id.stock, R.id.make, R.id.model);
    allSpinners = Arrays.asList(R.id.yearSpinner);
    setSpinners();
  }

  public void setSpinners() {
    List<String> years = new ArrayList<>();
    List<String> dealerStrings = new ArrayList<>();
    List<String> conditions = Arrays.asList(getResources()
        .getStringArray(R.array.new_vehicle_conditions));
    List<String> exteriorColors = Arrays.asList(getResources()
        .getStringArray(R.array.new_vehicle_exterior_colors));
    interiorColors = Arrays.asList(getResources()
        .getStringArray(R.array.new_vehicle_interior_colors));
    int thisYear = Calendar.getInstance().get(Calendar.YEAR) + 1;
    for (int i = 1900; i <= thisYear; i++) {
      years.add(Integer.toString(i));
    }
    years.add(getResources().getString(R.string.select));
    Collections.sort(years, Collections.reverseOrder());
    for (Dealer dealer : dealers) {
      dealerStrings.add(dealer.getDealerName());
    }
    dealerSelectionAdapter = new ArrayAdapter<>(NewVehicleActivity.this,
        R.layout.spinner_item_dealer, dealerStrings);
    interiorColorAdapter = new CustomArray(this,
        R.layout.spinner_item, interiorColors);
    conditionAdapter = new CustomArray(this,
        R.layout.spinner_item, conditions);
    yearAdapter = new CustomArray(this,
        R.layout.spinner_item, years);
    exteriorColorAdapter = new CustomArray(this,
        R.layout.spinner_item, exteriorColors);
    binding.dealerShipSpinner.setAdapter(dealerSelectionAdapter);
    binding.intColorSpinner.setAdapter(interiorColorAdapter);
    binding.exColorSpinner.setAdapter(exteriorColorAdapter);
    binding.yearSpinner.setAdapter(yearAdapter);
    binding.conditionSpinner.setAdapter(conditionAdapter);
  }

  private void inflateCustomActionBar() {
    customActionBar = getSupportActionBar();
    customActionBar.setDisplayShowTitleEnabled(false);
    customActionBar.setDisplayUseLogoEnabled(false);
    customActionBar.setDisplayHomeAsUpEnabled(false);
    customActionBar.setDisplayShowCustomEnabled(true);
    customActionBar.setDisplayShowHomeEnabled(false);
    ActionBar.LayoutParams layoutParams = new ActionBar
        .LayoutParams(ActionBar.LayoutParams.MATCH_PARENT,
        ActionBar.LayoutParams.WRAP_CONTENT);
    final View customView = LayoutInflater.from(applicationContext.get())
        .inflate(R.layout.actionbar_newvehicle, null);
    customActionBar.setCustomView(customView, layoutParams);
    ImageView closeBtn = customView.findViewById(R.id.close_btn);
    closeBtn.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        showDiscardChangedAlert();
      }
    });
    saveBtnProgress = customView.findViewById(R.id.save_btn_progress);
    saveBtn = customView.findViewById(R.id.save);
    saveBtn.setOnClickListener(new OnClickListener() {
      @Override
      public void onClick(View v) {
        if (editMode && !alreadyUploaded && !deleteNote) {
          updateOrder();
        } else if (alreadyUploaded && !deleteNote) {
          updateNoteOrder();
        } else if (deleteNote) {
          deleteNoteFromApi();
        } else {
          addOrderToApi();
        }
      }
    });
  }

  public void deleteNoteFromApi() {
    show(saveBtnProgress);
    hide(saveBtn);
    new ApiCall(applicationContext.get(), new ApiCallback<ApiResponse>() {
      @Override
      public void onCallFinished(ApiResponse result) {
        ContentValues contentValues = new ContentValues();
        contentValues.putNull(OrderEntry.COLUMN_NOTE);
        hide(saveBtnProgress);
        show(saveBtn);
        OrderFactory.getOrderInstance(String.valueOf(orderId)).setNote(null);
        dbController.updateOrderId(orderId, username, contentValues);
        finish();
      }
    }).deleteNote(OrderFactory.getOrderInstance(String.valueOf(orderId)).getUniqueOrderId(), token);
  }

  public void updateOrder() {
    Data data = new Data();
    data.setFlag(note);
    show(saveBtnProgress);
    hide(saveBtn);
    new ApiCall(applicationContext.get(), new ApiCallback<ApiResponse>() {
      @Override
      public void onCallFinished(ApiResponse result) {
        hide(saveBtnProgress);
        show(saveBtn);
        addOrdersFactory(orderId);
        dbController.updateOrderId(orderId, username, getContentOfFields());
        finish();
      }
    }).updateOrder(OrderFactory.getOrderInstance(String.valueOf(orderId)).getUniqueOrderId(), token,
        data);
  }

  public void updateNoteOrder() {
    Data data = new Data(note);
    show(saveBtnProgress);
    hide(saveBtn);
    new ApiCall(applicationContext.get(), new ApiCallback<ApiResponse>() {
      @Override
      public void onCallFinished(ApiResponse result) {
        hide(saveBtnProgress);
        show(saveBtn);
        ContentValues contentValues = new ContentValues();
        contentValues.put(OrderEntry.COLUMN_NOTE, note);
        OrderFactory.getOrderInstance(String.valueOf(orderId)).setNote(note);
        dbController.updateOrderId(orderId, username, contentValues);
        finish();
      }
    }).updateOrder(OrderFactory.getOrderInstance(String.valueOf(orderId)).getUniqueOrderId(), token,
        data);
  }

  public void attachToken() {
    token = sharedpreferences.getString(HomeActivity.TOKEN, "");
  }

  public void addOrderToApi() {
    Data data = setupData();
    show(saveBtnProgress);
    hide(saveBtn);
    newOrderListener().createOrder(token, data);
  }

  private Data setupData() {
    String condition =  "Select".equals(binding.conditionSpinner.getSelectedItem()
            .toString())? "":binding.conditionSpinner.getSelectedItem()
            .toString();
    String exteriorColor =  "Select".equals(binding.exColorSpinner.getSelectedItem()
            .toString())? "":binding.conditionSpinner.getSelectedItem()
            .toString();
    String interiorColor =  "Select".equals(binding.intColorSpinner.getSelectedItem()
            .toString())? "":binding.conditionSpinner.getSelectedItem()
            .toString();
    Data data = new Data(dealers.get(selectedDealer).getDealerId(),
        binding.vin.getText().toString(),
        binding.stock.getText().toString(), binding.yearSpinner.getSelectedItem()
        .toString(), binding.make.getText().toString(), binding.model.getText()
        .toString(),condition,exteriorColor,interiorColor);
    data.setUsingAndroid("YES");
    return data;
  }

  public long addOrderToDatabase() {
    return dbController.addOrder(getContentOfFields());
  }

  public ContentValues getContentOfFields() {
    ContentValues cv = new ContentValues();

    String condition =  "Select".equals(binding.conditionSpinner.getSelectedItem()
            .toString())? "":binding.conditionSpinner.getSelectedItem()
            .toString();
    String exteriorColor =  "Select".equals(binding.exColorSpinner.getSelectedItem()
            .toString())? "":binding.conditionSpinner.getSelectedItem()
            .toString();
    String interiorColor =  "Select".equals(binding.intColorSpinner.getSelectedItem()
            .toString())? "":binding.conditionSpinner.getSelectedItem()
            .toString();
    cv.put(OrderEntry.COLUMN_USERNAME, username);
    cv.put(OrderEntry.COLUMN_NOTE, note);
    cv.put(OrderEntry.COLUMN_STATUS, "NOT_UPLOADED");
    cv.put(OrderEntry.COLUMN_VINCODE, binding.vin.getText().toString());
    cv.put(OrderEntry.COLUMN_STOCK, binding.stock.getText().toString());
    cv.put(OrderEntry.COLUMN_YEAR, binding.yearSpinner.getSelectedItem().toString());
    cv.put(OrderEntry.COLUMN_MAKE, binding.make.getText().toString());
    cv.put(OrderEntry.COLUMN_MODEL, binding.model.getText().toString());
    cv.put(OrderEntry.COLUMN_CONDITION, condition);
    cv.put(OrderEntry.COLUMN_EXTERIOR, exteriorColor);
    cv.put(OrderEntry.COLUMN_INTERIORCOLOR, interiorColor);
    cv.put(OrderEntry.COLUMN_DEALERSHIP, dealers.get(selectedDealer).getDealerId());
    if (!editMode) {
      cv.put(OrderEntry.COLUMN_TIMESTAMP, System.currentTimeMillis() / 1000L);
    }
    if (uniqueOrderApiId != null) {
      cv.put(OrderEntry.COLUMN_UNIQUE_API_ID, uniqueOrderApiId);
    }
    return cv;
  }

  public void addOrdersFactory(int orderId) {
    String stringOrderId = String.valueOf(orderId);
    String condition =  "Select".equals(binding.conditionSpinner.getSelectedItem()
            .toString())? "":binding.conditionSpinner.getSelectedItem()
            .toString();
    String exteriorColor =  "Select".equals(binding.exColorSpinner.getSelectedItem()
            .toString())? "":binding.conditionSpinner.getSelectedItem()
            .toString();
    String interiorColor =  "Select".equals(binding.intColorSpinner.getSelectedItem()
            .toString())? "":binding.conditionSpinner.getSelectedItem()
            .toString();
    OrderFactory.getOrderInstance(stringOrderId).setOrderId(orderId);
    OrderFactory.getOrderInstance(stringOrderId).setImagesAdded(imagesAdded);
    OrderFactory.getOrderInstance(stringOrderId).setVinNumber(binding.vin.getText().toString());
    OrderFactory.getOrderInstance(stringOrderId).setStock(binding.stock.getText().toString());
    OrderFactory.getOrderInstance(stringOrderId)
        .setVehicleYear(binding.yearSpinner.getSelectedItem()
            .toString());
    OrderFactory.getOrderInstance(stringOrderId).setMake(binding.make.getText().toString());
    OrderFactory.getOrderInstance(stringOrderId).setModel(binding.model.getText().toString());
    OrderFactory.getOrderInstance(stringOrderId).setVehicleCondition(condition);
    OrderFactory.getOrderInstance(stringOrderId).setNote(note);
    OrderFactory.getOrderInstance(stringOrderId).setExteriorColor(exteriorColor);
    OrderFactory.getOrderInstance(stringOrderId).setInteriorColor(interiorColor);
    OrderFactory.getOrderInstance(stringOrderId)
        .setDealership(dealers.get(selectedDealer).getDealerName());
    OrderFactory.getOrderInstance(stringOrderId).setOrderUploadStatus("NOT_UPLOADED");
    if (uniqueOrderApiId != null) {
      OrderFactory.getOrderInstance(stringOrderId).setUniqueOrderId(uniqueOrderApiId);
    }
  }

  public boolean checkFields() {
    boolean foundEmtyField = true;
    for (int i = 0; i < allFields.size(); i++) {
      EditText field = findViewById(allFields.get(i));
      if ("".equals(field.getText().toString())) {
        if (photosButtonClicked) {
          ColorStateList colorStateList = ColorStateList
              .valueOf(getResources().getColor(R.color.colorLightRed));
          field.setBackgroundTintList(colorStateList);
        }
        foundEmtyField = false;
      } else {
        if (photosButtonClicked) {
          ColorStateList colorStateList = ColorStateList
              .valueOf(getResources().getColor(R.color.underline_color));
          field.setBackgroundTintList(colorStateList);
        }
      }
    }
    return foundEmtyField;
  }

  private boolean checkSpecialCharactors(String word) {
    boolean foudnMatch = false;
    Pattern regex = Pattern.compile("[$&+,:;=\\\\\\\\?@#|/'<>.^*()%!]");
    if (regex.matcher(word).find()) {
      foudnMatch = true;
    }
    return foudnMatch;
  }

  public boolean checkSpinners() {
    boolean noSpinnerSelected = true;
    for (int i = 0; i < allSpinners.size(); i++) {
      Spinner field = findViewById(allSpinners.get(i));
      if (getResources().getString(R.string.select).equals(field.getSelectedItem())) {
        noSpinnerSelected = false;
        if (photosButtonClicked) {
          ColorStateList colorStateList = ColorStateList
              .valueOf(getResources().getColor(R.color.colorLightRed));
          field.setBackgroundTintList(colorStateList);
        }
      } else {
        if (photosButtonClicked) {
          ColorStateList colorStateList = ColorStateList
              .valueOf(getResources().getColor(R.color.underline_color));
          field.setBackgroundTintList(colorStateList);
        }
      }
    }
    return noSpinnerSelected;
  }

  public void showAlert() {
    new AlertDialog.Builder(applicationContext.get(), R.style.MyAlertDialogStyle)
        .setIcon(android.R.drawable.ic_dialog_alert)
        .setMessage(R.string.please_fill)
        .setPositiveButton("OK", null)
        .show();
  }

  public boolean specialCharacters() {
    boolean foundError = false;
    for (int i = 0; i < allFields.size(); i++) {
      EditText field = findViewById(allFields.get(i));
      String fieldWord = field.getText().toString();
      if (checkSpecialCharactors(fieldWord)) {
        ColorStateList colorStateList = ColorStateList
            .valueOf(getResources().getColor(R.color.colorLightRed));
        field.setBackgroundTintList(colorStateList);
        foundError = true;
      } else {
        ColorStateList colorStateList = ColorStateList
            .valueOf(getResources().getColor(R.color.underline_color));
        field.setBackgroundTintList(colorStateList);
      }
    }
    return foundError;
  }

  private void showAlertOfSpecialCharacters() {
    android.app.AlertDialog.Builder builder = new android.app.AlertDialog.Builder(
        applicationContext.get(),
        R.style.MyAlertDialogStyle);
    builder.setMessage("Please remove special characters"
        + " \n Characters like : !@#$%^&*()+")
        .setPositiveButton(R.string.ok, null);
    android.app.AlertDialog dialog = builder.show();
    dialog.setCancelable(false);
    dialog.setCanceledOnTouchOutside(false);
  }

  @Override
  public void onClick(View v) {
    switch (v.getId()) {
      case R.id.noteButton:
        showAddnote();
        break;
      case R.id.photosButton:
        photosButtonClicked = true;
        if (checkFields() && checkSpinners()) {
          photosButtonClicked = false;
          if (specialCharacters()) {
            showAlertOfSpecialCharacters();
            return;
          }
          if (imagesAdded > 0) {
            Intent intent = new Intent(getApplicationContext(), ImagesSelectionActivity.class);
            intent.putParcelableArrayListExtra("stencils",
                (ArrayList<? extends Parcelable>) dealerStencilsObjects);
            intent.putExtra("username", username);
            intent.putExtra("orderId", orderId);
            startActivity(intent);
          } else {
            if (orderCreated) {
              Intent intent = new Intent(getApplicationContext(), WeatherSelectionActivity.class);
              intent.putExtra("startshooting", true);
              OrderFactory.getOrderInstance(String.valueOf(orderId)).setStencilIds(dealersStencils);
              intent.putExtra("orderId", orderId);
              startActivity(intent);
            } else {
              if (!editMode) {
                orderId = (int) addOrderToDatabase();
                addOrdersFactory(orderId);
              }
              orderCreated = true;
              Intent intent = new Intent(getApplicationContext(), WeatherSelectionActivity.class);
              OrderFactory.getOrderInstance(String.valueOf(orderId)).setStencilIds(dealersStencils);
              intent.putExtra("startshooting", true);
              intent.putExtra("orderId", orderId);
              startActivity(intent);
            }
          }
        } else {
          showAlert();
        }
        break;
      case R.id.delete_vehicle:
        show(binding.deleteProgressBar);
        if (!OrderFactory.getOrderInstance(String.valueOf(orderId)).getUniqueOrderId()
            .equals("null")) {
          new ApiCall(applicationContext.get(), new ApiCallback<ApiResponse>() {
            @Override
            public void onCallFinished(ApiResponse result) {
              if ("success".equals(result.getType())) {
                deleteLocalOrder(orderId);
                hide(binding.deleteProgressBar);
                Intent intent = new Intent();
                setResult(RESULT_OK, intent);
                intent.putExtra("order_deleted", true);
                finish();
              }
            }
          }).deleteOrder(OrderFactory.getOrderInstance(String.valueOf(orderId)).getUniqueOrderId(),
              token);
        } else {
          deleteLocalOrder(orderId);
          Intent intent = new Intent();
          setResult(RESULT_OK, intent);
          intent.putExtra("order_deleted", true);
          finish();
        }
        break;
    }
  }

  public void deleteLocalOrder(int orderId) {
    List<OrderImages> photos = dbController.getOrderImage(orderId);
    for (OrderImages image : photos) {
      String imageLocation = image.getImageLocation();
      File file = new File(applicationContext.get().getExternalFilesDir(null), imageLocation);
      file.delete();
    }
    dbController.deleteOrder(orderId);
    OrderFactory.removeIntance(String.valueOf(orderId));
  }

  private void showAddnote() {
    LayoutInflater inflater = LayoutInflater.from(applicationContext.get());
    View subView = inflater.inflate(R.layout.addnote_screen, null);
    final EditText subEditText = subView.findViewById(R.id.editText);
    final ImageView closeBtn = subView.findViewById(R.id.close_btn);
    final Button getNote = subView.findViewById(R.id.finishBtn);
    final TextView removeNote = subView.findViewById(R.id.remove_note);
    if (note == null || "".equals(note)) {
      getNote.setText(R.string.add_note);
      removeNote.setVisibility(View.INVISIBLE);
    } else {
      subEditText.setText(note);
      getNote.setText(R.string.edit_note);
      removeNote.setVisibility(View.VISIBLE);
    }
    AlertDialog.Builder builder = new AlertDialog.Builder(applicationContext.get());
    builder.setView(subView);
    final AlertDialog alertDialog = builder.create();
    subEditText.requestFocus();
    final InputMethodManager imm = (InputMethodManager) getSystemService(
        Context.INPUT_METHOD_SERVICE);
    imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
    closeBtn.setOnClickListener(new OnClickListener() {
      @Override
      public void onClick(View v) {
        imm.hideSoftInputFromWindow(subEditText.getWindowToken(), 0);
        alertDialog.dismiss();
      }
    });
    getNote.setOnClickListener(new OnClickListener() {
      @Override
      public void onClick(View v) {
        if (subEditText.getText().length() > 0) {
          binding.noteText.setText(R.string.edit_note);
          note = subEditText.getText().toString();
          if (alreadyUploaded && subEditText.getText().length() > 0
              || editMode && subEditText.getText().length() > 0) {
            enableSaveBtn();
          }
        }
        imm.hideSoftInputFromWindow(subEditText.getWindowToken(), 0);
        alertDialog.dismiss();
      }
    });
    removeNote.setOnClickListener(new OnClickListener() {
      @Override
      public void onClick(View v) {
        note = "";
        binding.noteText.setText(R.string.add_note);
        imm.hideSoftInputFromWindow(subEditText.getWindowToken(), 0);
        alertDialog.dismiss();
        deleteNote = true;
        enableSaveBtn();
      }
    });
    alertDialog.show();
  }

  public static void show(View view) {
    view.setVisibility(View.VISIBLE);
  }

  public static void hide(View view) {
    view.setVisibility(View.INVISIBLE);
  }

  public void attachFields(Data data) {
    if (data.getCondition() != null) {
      int spinnerPosition = conditionAdapter.getPosition(data.getCondition());
      binding.conditionSpinner.setSelection(spinnerPosition);
    }
    if (data.getExteriorColor() != null) {
      if (!"".equals(data.getExteriorColor())) {
        int spinnerPosition = exteriorColorAdapter
            .getPosition(data.getExteriorColor());
        binding.exColorSpinner.setSelection(spinnerPosition);
      }
    }
    if (data.getInteriorColor() != null) {
      if (!"".equals(data.getInteriorColor())) {
        int spinnerPosition = interiorColorAdapter
            .getPosition(data.getInteriorColor());
        binding.intColorSpinner.setSelection(spinnerPosition);
      }
    }
    if (data.getYear() != null) {
      if (!"".equals(data.getYear())) {
        int spinnerPosition = yearAdapter
            .getPosition(String.valueOf(data.getYear()));
        binding.yearSpinner.setSelection(spinnerPosition);
      }
    }
    allFields = Arrays.asList(R.id.vin, R.id.stock, R.id.make, R.id.model);
    if (data.getMake() != null) {
      if (!"".equals(data.getMake())) {
        TextView make = findViewById(allFields.get(2));
        make.setText(data.getMake());
      }
    }
    if (data.getVin() != null) {
      if (!"".equals(data.getVin())) {
        TextView vin = findViewById(allFields.get(0));
        vin.setText(data.getVin().toString());
      }
    }
    if (data.getStock() != null) {
      if (!"".equals(data.getStock())) {
        TextView stock = findViewById(allFields.get(1));
        stock.setText(data.getStock());
      }
    }
    if (data.getModel() != null) {
      if (!"".equals(data.getModel())) {
        TextView model = findViewById(allFields.get(3));
        model.setText(data.getModel());
      }
    }
  }

  @Override
  protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (data == null) {
      return;
    }
    switch (requestCode) {
      case SCANNER_RESULT_CODE: {
        checkVinWithApi(data.getStringExtra(VIN));
        break;
      }
      case IMAGES_RESULT_CODE: {
        if (OrderFactory.getOrderInstance(String.valueOf(orderId)).getImagesAdded() > imagesAdded) {
          imagesAdded = OrderFactory.getOrderInstance(String.valueOf(orderId)).getImagesAdded();
        }
        enableSaveBtn();
      }
    }
    super.onActivityResult(requestCode, resultCode, data);
  }

  private void checkVinWithApi(String vin) {
    binding.smallScan.setVisibility(View.INVISIBLE);
    binding.tvSearchCaption.setVisibility(View.INVISIBLE);
    binding.apiCallProgressBar.setVisibility(View.VISIBLE);
    getVinDecodeCall().vinDecoder(token, vin, dealerId);
  }

  public void showInvalidVinError() {
    android.app.AlertDialog.Builder builder = new android.app.AlertDialog.Builder(
        applicationContext.get(),
        R.style.MyAlertDialogStyle);
    builder.setTitle(R.string.invalid_vin_title)
        .setMessage(R.string.invalid_vin_message)
        .setPositiveButton(R.string.ok, null);
    android.app.AlertDialog dialog = builder.show();
    dialog.setCancelable(false);
    dialog.setCanceledOnTouchOutside(false);
  }

  private void attachApiInfo() {
    switch (apiResponse.getType()) {
      case "invalid": {
        showInvalidVinError();
        break;
      }
      case "success": {
        attachFields(apiResponse.getData());
        break;
      }
      case "reshoot": {
        DialogInterface.OnClickListener dialogClickListener = new DialogInterface.OnClickListener() {
          @Override
          public void onClick(DialogInterface dialog, int which) {
            switch (which) {
              case DialogInterface.BUTTON_POSITIVE:
                attachFields(apiResponse.getData());
                dialog.cancel();
                break;
              case DialogInterface.BUTTON_NEGATIVE:
                binding.vin.setText(EMPTY_STRING);
                dialog.cancel();
                break;
            }
          }
        };

        android.app.AlertDialog.Builder builder = new android.app.AlertDialog.Builder(
            applicationContext.get(),
            R.style.MyAlertDialogStyle);
        builder.setTitle(R.string.already_shot_title)
            .setMessage(R.string.already_shot_message)
            .setPositiveButton(R.string.yes, dialogClickListener)
            .setNegativeButton(R.string.no, dialogClickListener);
        if(!(this).isFinishing())
        {
          android.app.AlertDialog dialog = builder.show();
          dialog.setCancelable(false);
          dialog.setCanceledOnTouchOutside(false);
          break;
        }
      }
      default: {
        break;
      }
    }
  }
}