puts "Creating warehouses"

warehouses = [
  {code: 'KOL', eg_code: 'LOK', drug_license_number: '123', store_name: 'warehouse1'},
  {code: 'PNQ', eg_code: 'QNP', drug_license_number: '456', store_name: 'warehouse2'}
]

warehouses.each do |data|
  puts "creating warehouse with code: #{data.fetch(:code)}"
  warehouse = Warehouse.find_or_initialize_by(code: data.fetch(:code))
  warehouse.eg_code = data.fetch(:eg_code)
  warehouse.drug_license_number = data.fetch(:drug_license_number)
  warehouse.store_name = data.fetch(:store_name)
  warehouse.fulfillment_center_type = 1
  warehouse.active = true
  warehouse.update!(data)
end

puts "Creating cities"

cities = [
  {warehouse_code: 'KOL', name: 'Kolkata', state: 'WG', country: 'India', max_allowed_cod_paise: 5000000, customer_care_number: '0336666666', customer_care_starts_at: '08:00', customer_care_closes_at: '20:00'},
  {warehouse_code: 'PNQ', name: 'Pune', state: 'MH', country: 'India', max_allowed_cod_paise: 5000000, customer_care_number: '0212666666', customer_care_starts_at: '08:00', customer_care_closes_at: '20:00'}
]

cities.each do |data|
  puts "creating - #{data.inspect}"

  warehouse = Warehouse.find_by_code(data.fetch(:warehouse_code))
  city = City.find_or_initialize_by(name: data[:name])
  data.merge!({warehouse_id: warehouse.id}).except!(:warehouse_code)
  city.update_attributes!(data)
end

puts "\nCreating areas"

areas = [
  {pincode: 411028, name: 'Hadapsar', city_name: 'Pune'},
  {pincode: 411029, name: 'kothrud', city_name: 'Pune'},
  {pincode: 411030, name: 'Chinchwad', city_name: 'Pune'},
  {pincode: 700001, name: 'Rajrhat', city_name: 'Kolkata'}
]

areas.each do |data|
  puts "creating - #{data.inspect}"

  city = City.find_by_name(data[:city_name])
  area = Area.find_or_initialize_by(city_id: city.id, name: data[:name])
  area.update_attributes!(data.except(:city_name))
end


puts "\nCreating categories"

categories = [
  {name: 'Pharmacy', category_type: Category.category_types["MC1"], pharmacy: true},
  {name: 'Health Care', category_type: Category.category_types["MC2"], parent_name: 'Pharmacy', pharmacy: true},
  {name: 'Hair Care', category_type: Category.category_types["MC3"], parent_name: 'Health Care', pharmacy: true},
  {name: 'Cosmetics', category_type: Category.category_types["MC1"], pharmacy: false},
  {name: 'Beauty Products', category_type: Category.category_types["MC2"], parent_name: 'Cosmetics', pharmacy: false},
  {name: 'Lipsticks', category_type: Category.category_types["MC3"], parent_name: 'Beauty Products', pharmacy: false},
  {name: 'Health And Digestion', category_type: Category.category_types["MC2"], parent_name: 'Pharmacy', pharmacy: true},
  {name: 'Digestive Aids', category_type: Category.category_types["MC3"], parent_name: 'Health And Digestion', pharmacy: true}
]

categories.each do |data|
  puts "creating - #{data.inspect}"

  parent = Category.find_by_name(data[:parent_name])
  data = data.merge(parent_id: parent.try(:id))
  category = Category.find_or_initialize_by(name: data[:name], category_type: data[:category_type])
  category.update_attributes!(data.except(:parent_name))
end


puts "\nCreating product types"

product_types = [
  {name: 'pharmacy_products', category_name: 'Pharmacy'},
  {name: 'beauty_products', category_name: 'Cosmetics'}
]

product_types.each do |data|
  puts "creating - #{data.inspect}"

  category = Category.mc1.find_by_name(data[:category_name])
  data = data.merge(category_id: category.id)
  product_type = ProductType.find_or_initialize_by(name: data[:name])
  product_type.update_attributes!(data.except(:category_name))
end


puts "\nCreating users"

users = [
  {name: "Catalogue Admin",
    email: "catalogueadmin@example.com", password: "welcome",
    roles: ["catalogue_manager"],
    primary_phone: {
      number: '8888888888',
      verified: true,
      phone_type: 'Mobile',
      primary: true
    }
  },
  {name: "Category Admin",
    email: "categoryadmin@example.com", password: "welcome",
    roles: ["category_manager"]},
  {name: "EMR",
    email: "emr@example.com", password: "welcome",
    roles: ["emr"],
    authentication_token: "QqYXW_Su1qdbFUoYwjb1"},
  {name: "User Standard",
    email: "user@example.com", password: "welcome",
    primary_phone: {
      number: '9238100975',
      phone_type: 'Mobile',
      verified: true,
      primary: true
    },
    roles: ["standard"]
  },
  {name: "Super Admin",
    email: "admin@example.com", password: "welcome",
    roles: ["super_admin"]},
  {name: "Vinculum API",
    email: "vinculum@example.com", password: "welcome",
    roles: ["warehouse_manager"]},
  {name: "Asset Tracker API",
    email: "asset-tracker@example.com", password: "welcome",
    roles: ["asset_tracker"]},
  {name: "CCE User",
    email: "cce@example.com", password: "welcome",
    roles: ["call_center_executive"]},
  {name: "Compliance Manager",
    email: "compliance-manager@example.com", password: "welcome",
    roles: ["compliance_manager"]}
]

users.each do |attributes|
  data = attributes.except(:primary_phone)
  puts "creating - #{data.inspect}"
  user = User.find_or_initialize_by(email: data[:email])
  if user.id
    user.update_attributes!(data.except(:password))
  else
    user.update_attributes!(data.merge(password_confirmation: data[:password]))
  end
  if phone_attributes = attributes[:primary_phone]
    phone = user.primary_phone || user.phones.new
    puts "Updating #{user.name}'s phone to #{phone_attributes}"
    phone.update_attributes!(phone_attributes)
  end
end


puts "\nCreating Shipping Rules"

shipping_rules = [
  {min_value_paise: 0, max_value_paise: 10000, shipping_cost_paise: 5000, city_name: 'Pune'},
  {min_value_paise: 10001, max_value_paise: 20000, shipping_cost_paise: 4000, city_name: 'Pune'},
  {min_value_paise: 20001, max_value_paise: 50000, shipping_cost_paise: 2500, city_name: 'Pune'}
]

shipping_rules.each do |data|
  puts "creating - #{data.inspect}"
  city = City.find_by_name(data[:city_name])
  rule = ShippingRule.find_or_initialize_by(city_id: city.id, min_value_paise: data[:min_value_paise])
  rule.update_attributes!(data.except(:city_name))
end


puts "\nCreating properties"

properties = [
  {name: Variant::PRESCRIPTION_REQUIRED_PROPERTY_NAME, input_type: Property.input_types["boolean"]},
  {name: Variant::MAX_ORDER_SIZE_PROPERTY_NAME, input_type: Property.input_types["number"]},
  {name: 'dummy_property', input_type: Property.input_types["string"]},
  {name: 'unit_of_sale', input_type: Property.input_types["string"]},
  {name: 'inner_package_quantity', input_type: Property.input_types["number"]},
  {name: 'schedule', input_type: Property.input_types["dropdown"]},
]

properties.each do |data|
  puts "creating - #{data.inspect}"
  property = Property.find_or_initialize_by(name: data[:name], display_name: data[:name].gsub('_', ' ').camelize)
  property.update_attributes!(data)
end

puts "\nCreating ProductTypeProperties"

product_type_properties = [
  {product_type_name: 'pharmacy_products', property_name: Variant::PRESCRIPTION_REQUIRED_PROPERTY_NAME, on_variant: true, mandatory: true, user_accessible: true},
  {product_type_name: 'pharmacy_products', property_name: Variant::MAX_ORDER_SIZE_PROPERTY_NAME, on_variant: false, mandatory: false, user_accessible: true},
  {product_type_name: 'pharmacy_products', property_name: 'dummy_property', on_variant: false, mandatory: false, user_accessible: true},
  {product_type_name: 'pharmacy_products', property_name: 'inner_package_quantity', on_variant: false, mandatory: false, user_accessible: true},
  {product_type_name: 'pharmacy_products', property_name: 'unit_of_sale', on_variant: false, mandatory: false, user_accessible: true},
  {product_type_name: 'pharmacy_products', property_name: 'schedule', on_variant: true, mandatory: true, user_accessible: true, valid_values: ['Schedule H', 'Schedule H1']},

  {product_type_name: 'beauty_products', property_name: Variant::MAX_ORDER_SIZE_PROPERTY_NAME, on_variant: false, mandatory: false, user_accessible: true},
  {product_type_name: 'beauty_products', property_name: 'dummy_property', on_variant: false, mandatory: false, user_accessible: true},
  {product_type_name: 'beauty_products', property_name: 'unit_of_sale', on_variant: false, mandatory: false, user_accessible: true},
  {product_type_name: 'beauty_products', property_name: 'inner_package_quantity', on_variant: false, mandatory: false, user_accessible: true},
]

product_type_properties.each do |data|
  puts "creating - #{data.inspect}"
  product_type = ProductType.find_by_name(data[:product_type_name])
  property = Property.find_by_name(data[:property_name])
  ptp = ProductTypeProperty.find_or_initialize_by(product_type: product_type, property: property)
  ptp.update_attributes! data.except(:product_type_name, :property_name)
end


puts "\nCreating Brands"
brands = [
  {
    name: 'himalaya'
  },
  {
    name: 'alkem'
  }
]

brands.each do |data|
  unless Brand.where(data).exists?
    puts "Creating Brand: #{data.inspect}"
    Brand.create!(data)
  end
end

brand_himalaya = Brand.find_by_name('himalaya')
brand_alkem = Brand.find_by_name('alkem')
puts "\nCreating Products"

products = [
  {
    name: 'Himalaya Herbals Purifying Neem Face Wash', sku: Item::SKU_PENDING,
    product_type_name: 'beauty_products', active: true, primary_category_name: 'Beauty Products', manufacturer: 'Himalaya',
    brand: brand_himalaya,
    item_properties: [
      {property_name: Variant::MAX_ORDER_SIZE_PROPERTY_NAME, property_value: 10},
      {property_name: 'dummy_property', property_value: nil},
      {property_name: 'unit_of_sale', property_value: 'Pack'},
      {property_name: 'inner_package_quantity', property_value: 10},
    ]
  },
  {
    name: 'Himalaya Herbals Baby Soap (Honey and Milk)', sku: Item::SKU_PENDING,
    product_type_name: 'beauty_products', active: true, primary_category_name: 'Beauty Products', manufacturer: 'Himalaya',
    brand: brand_himalaya,
    item_properties: [
      {property_name: Variant::MAX_ORDER_SIZE_PROPERTY_NAME, property_value: 10},
      {property_name: 'dummy_property', property_value: nil},
      {property_name: 'unit_of_sale', property_value: 'Pack'},
      {property_name: 'inner_package_quantity', property_value: 10},
    ]
  },
  {
    name: 'PAN - D', sku: Item::SKU_PENDING,
    product_type_name: 'pharmacy_products', active: true, primary_category_name: 'Pharmacy', manufacturer: 'Alkem',
    brand: brand_alkem,
    item_properties: [
      {property_name: Variant::PRESCRIPTION_REQUIRED_PROPERTY_NAME, property_value: 'TRUE'},
      {property_name: Variant::MAX_ORDER_SIZE_PROPERTY_NAME, property_value: 10},
      {property_name: 'dummy_property', property_value: nil},
      {property_name: 'unit_of_sale', property_value: 'Pack'},
      {property_name: 'inner_package_quantity', property_value: 10},
    ]
  },
  {
    name: 'PAN - A', sku: Item::SKU_PENDING,
    product_type_name: 'pharmacy_products', active: true, primary_category_name: 'Pharmacy', manufacturer: 'Alkem',
    brand: brand_alkem,
    item_properties: [
      {property_name: Variant::PRESCRIPTION_REQUIRED_PROPERTY_NAME, property_value: 'TRUE'},
      {property_name: Variant::MAX_ORDER_SIZE_PROPERTY_NAME, property_value: 10},
      {property_name: 'dummy_property', property_value: nil},
      {property_name: 'unit_of_sale', property_value: 'Pack'},
      {property_name: 'inner_package_quantity', property_value: 10},
    ]
  }
]

products.each do |data|
  puts "creating - #{data.inspect}"
  product_type = ProductType.find_by_name(data[:product_type_name])
  primary_category = Category.find_by_name(data[:primary_category_name])
  product = Product.find_or_initialize_by(name: data[:name])
  product.update_attributes! data.except(:product_type_name, :primary_category_name, :item_properties).merge(product_type: product_type, primary_category: primary_category)
  product.send(:assign_sku_after_import)
  product.save!

  data[:item_properties].each do |property_data|
    property = Property.find_by_name(property_data[:property_name])
    ptp = ProductTypeProperty.find_by(product_type: product_type, property: property)
    item_property = product.item_properties.find_or_initialize_by(property_id: property.id)
    item_property.update_attributes!(property_data.except(:property_name).merge(product_type_property: ptp))
  end
end


puts "\nCreating Variants"

variants = [
  {name: 'Himalaya Herbals Purifying Neem Face Wash 200ml', sku: Item::SKU_PENDING, active: true, product_name: 'Himalaya Herbals Purifying Neem Face Wash'},
  {name: 'Himalaya Herbals Purifying Neem Face Wash 500ml', sku: Item::SKU_PENDING, active: true, product_name: 'Himalaya Herbals Purifying Neem Face Wash'},
  {name: 'Himalaya Herbals Baby Soap (Honey and Milk) 75g', sku: Item::SKU_PENDING, active: true, product_name: 'Himalaya Herbals Baby Soap (Honey and Milk)'},
  {
    name: 'PAN - D', sku: Item::SKU_PENDING, active: true, product_name: 'PAN - D',
    item_properties: [{property_name: Variant::PRESCRIPTION_REQUIRED_PROPERTY_NAME, property_value: 'TRUE'}]
  },
  {
    name: 'PAN - A', sku: Item::SKU_PENDING, active: true, product_name: 'PAN - D',
    item_properties: [{property_name: Variant::PRESCRIPTION_REQUIRED_PROPERTY_NAME, property_value: 'TRUE'}]
  }
]

variants.each do |data|
  puts "creating - #{data.inspect}"

  product = Product.find_by_name(data[:product_name])
  variant = Variant.find_or_initialize_by(name: data[:name])
  variant.update_attributes! data.except(:product_name, :item_properties).merge(product: product)
  variant.send(:assign_sku_after_import)
  variant.save!

  data[:item_properties].each do |property_data|
    property = Property.find_by_name(property_data[:property_name])
    ptp = ProductTypeProperty.find_by(product_type: variant.product_type, property: property)
    item_property = variant.item_properties.find_or_initialize_by(property_id: property.id)
    item_property.update_attributes!(property_data.except(:property_name).merge(product_type_property: ptp))
  end if data[:item_properties]
end


puts "\nCreating VariantCity"

CityWarehouse.create(city_id: 1, warehouse_id: 1, default_city: true)
CityWarehouse.create(city_id: 2, warehouse_id: 2, default_city: true)


City.all.each do |city|
  first_for_city = nil
  second_for_city = nil

  Variant.all.each do |variant|
    puts "Creating VariantCity for #{city.name} & #{variant.name}"
    mrp = [100_00, 120_00, 140_00].sample
    variant_city_service = VariantStockUpdateService.new(city.warehouse, variant.sku, mrp, 1000)
    variant_city_service.process

    VariantCity.update_all(sales_price_paise: mrp, promotion_percent: 10, max_promotion_percent: 99.99,max_discount_percent: 10.00)
  end
end

puts "\nCreating Delivery Centers"

City.all.each do |city|
  puts "Creating DC for #{city.name}"
  dc = DistributionCenter.find_or_initialize_by(dc_code: "dc_#{city.name}")
  dc.update_attributes! dc_code_id: dc.dc_code
  city.areas.each { |area| area.update_attributes!(distribution_center_id: dc.id) }
end

puts "\nCreating Delivery Slots"

slot_timings = ['09:00-11:00', '11:00-13:00', '13:00-15:00', '15:00-17:00', '17:00-19:00']

DistributionCenter.all.each do |dc|
  (0..2).to_a.each do |day_diff|
    date = Date.today + day_diff.days
    slot_timings.each do |slot_timing|
      slot_id = "#{dc.id}-#{date}-#{slot_timing}"
      slot = DeliverySlot.find_or_initialize_by(slot_id: slot_id)
      data = {distribution_center_id: dc.id, slot_description: slot_timing, slot_date: date, on_hand_count: 20, allocated_count: 0}
      puts "Creating slot - #{data}"
      slot.update_attributes! data
    end
  end
end

#create orders in delivered state
puts "\nCreating Orders in delivered state"
cce_user = User.find_by_email('cce@example.com')
standard_user = User.find_by_email('emr@example.com')

City.all.each do |city|
  address = standard_user.addresses.first_or_create do |add|
    add.full_name = standard_user.name
    add.address_line_1 = 'foo address line 1'
    add.address_line_2 = 'bar address line 1'
    add.city = city
    add.area = city.areas.first
    add.phone_number = '0123456789'
  end
  order = Order.find_or_initialize_by(user: standard_user,
    city: city,
    created_by: cce_user,
    state: Order.states[:delivered],
    payment_method: Order::PAYMENT_METHODS.first,
    shipping_address: address,
    billing_address: address)
  order.save!
  variants = VariantCity.where(city: city).each do |vc|
    order.line_items.create(order: order,
      variant: vc.variant,
      quantity: 1,
      mrp_paise: vc.mrp_paise,
      total_paise: vc.mrp_paise,
      discount_amount_paise: 0,
      sales_price_paise: vc.sales_price_paise)
  end
end


puts "\nCreating Business Day seed data"

if BusinessDay.all.count == 0
  # .all returns active relation
  Rake::Task['one_off:initialize_business_days'].invoke
end

#omni channel seed data for development,
#many to many Associations between Area and warehouse

warehouses = [
  {code: 'DURG', eg_code: 'GRUD', drug_license_number: '789', store_name: 'warehouse3', fulfillment_center_type: 2, active: true},
  {code: 'BAR', eg_code: 'RAB', drug_license_number: '901', store_name: 'warehouse4', fulfillment_center_type: 2, active: true},
  {code: 'DUM', eg_code: 'MUD', drug_license_number: '111', store_name: 'warehouse5', fulfillment_center_type: 2, active: true},
  {code: 'HAL', eg_code: 'LAH', drug_license_number: '222', store_name: 'warehouse6', fulfillment_center_type: 2, active: true},
  {code: 'KAR', eg_code: 'RAK', drug_license_number: '333', store_name: 'warehouse7', fulfillment_center_type: 2, active: true},
  {code: 'NAI', eg_code: 'IAN', drug_license_number: '443', store_name: 'warehouse8', fulfillment_center_type: 2, active: true}
]
# warehouses = [
#   {code: 'KOL', eg_code: 'LOK', drug_license_number: '123', store_name: 'warehouse1'},
#   {code: 'PNQ', eg_code: 'QNP', drug_license_number: '456', store_name: 'warehouse2'}
# ]
warehouses.each do |data|
  warehouse = Warehouse.find_or_initialize_by(code: data.fetch(:code))
  warehouse.update!(data)
end


Area.all.each do |area|
  level = 0
  Warehouse.where(fulfillment_center_type: 2).order("RANDOM()").limit(3).each do |warehouse|
    area_warehouse = AreaWarehouse.find_or_initialize_by(area_id: area.id , warehouse_id: warehouse.id)
    level += 1
    area_warehouse.fulfillment_center_level = level
    area_warehouse.save
  end
end