import std/json, std/options, std/tables, std/times

import timeutils

import ../notion_utils

type
  NAddressObj* = object
    id*: string
    city*: string
    state*: string
    street*: string
    zipCode*: string
    createdAt*: Option[DateTime]
    lastUpdatedAt*: Option[DateTime]


  NFamilyObj* = object
    id*: string
    name*: string
    headOfHouseholdIds*: seq[string]
    primaryAddressId*: seq[string]
    memberIds*: seq[string]
    createdAt*: Option[DateTime]
    lastUpdatedAt*: Option[DateTime]

  NPersonObj* = object
    id*: string
    preferredName*: string
    firstName*: string
    middleNames*: string
    lastName*: string
    birthDate*: Option[DateTime]
    gender*: string
    primaryPhoneNumber*: string
    primaryEmailAddress*: string
    addressIds*: seq[string]
    marriedToId*: seq[string]
    anniversary*: Option[DateTime]
    parentIds*: seq[string]
    childIds*: seq[string]
    relationshipToHff*: seq[string]
    createdAt*: Option[DateTime]
    lastUpdatedAt*: Option[DateTime]

  NAddress* = ref NAddressObj
  NFamily* = ref NFamilyObj
  NPerson* = ref NPersonObj

func sameContents[T](a: seq[T], b: seq[T]): bool =
  let aCount = toCountTable(a)
  let bCount = toCountTable(b)

  for k in aCount.keys:
    if not bCount.hasKey(k) or aCount[k] != bCount[k]: return false

  return aCount.len == bCount.len


func `==`*(a, b: NFamily): bool =
  return a.name == b.name and
         sameContents(a.headOfHouseholdIds, b.headOfHouseholdIds) and
         sameContents(a.primaryAddressId, b.primaryAddressId) and
         sameContents(a.memberIds, b.memberIds)

func `==`*(a, b: NPerson): bool =
  return a.preferredName == b.preferredName and
         a.firstName == b.firstName and
         a.middleNames == b.middleNames and
         a.lastName == b.lastName and
         a.birthDate == b.birthDate and
         a.gender == b.gender and
         a.primaryPhoneNumber == b.primaryPhoneNumber and
         a.primaryEmailAddress == b.primaryEmailAddress and
         a.anniversary == b.anniversary and
         sameContents(a.addressIds, b.addressIds) and
         sameContents(a.marriedToId, b.marriedToId) and
         sameContents(a.parentIds, b.parentIds) and
         sameContents(a.childIds, b.childIds) and
         sameContents(a.relationshipToHff, b.relationshipToHff)

func toPage*(a: NAddress): JsonNode =
  %*{
    "properties": {
      "City": makeTextProp("rich_text", a.city),
      "State": makeSelectProp(a.state),
      "Street Address": makeTextProp("title", a.street),
      "Zip Code": makeTextProp("rich_text", a.zipCode)
    }
  }

func toPage*(f: NFamily): JsonNode =
  %*{
    "properties": {
      "Name": makeTextProp("title", f.name),
      "Head(s) of Household": makeRelationProp(f.headOfHouseholdIds),
      "Primary Address": makeRelationProp(f.primaryAddressId),
      "Members": makeRelationProp(f.memberIds)
    }
  }

func toPage*(p: NPerson): JsonNode =
  %*{
    "properties": {
      "Preferred Name": makeTextProp("title", p.preferredName),
      "First Name": makeTextProp("rich_text", p.firstName),
      "Middle Names": makeTextProp("rich_text", p.middleNames),
      "Last Name": makeTextProp("rich_text", p.lastName),
      "Birth Date": makeDateProp(p.birthDate),
      "Gender": makeSelectProp(p.gender),
      "Primary Phone Number": { "phone_number": p.primaryPhoneNumber },
      "Email Address": { "email": p.primaryEmailAddress },
      "Relationship to HFF": makeMultiSelectProp(p.relationshipToHff),
      "Address": makeRelationProp(p.addressIds),
      "Married To": makeRelationProp(p.marriedToId),
      "Anniversary": makeDateProp(p.anniversary),
      "Parents": makeRelationProp(p.parentIds),
      "Children": makeRelationProp(p.childIds),
    }
  }

proc parseNAddress*(page: JsonNode): NAddress =
  result = NAddress(
    id: page["id"].getStr,
    city: page.getText("City"),
    state: page.getSelect("State"),
    street: page.getTitle("Street Address"),
    zipCode: page.getText("Zip Code"),
    createdAt: some(parseIso8601(page["created_time"].getStr)),
    lastUpdatedAt: some(parseIso8601(page["last_edited_time"].getStr)))

proc parseNFamily*(page: JsonNode): NFamily =
  result = NFamily(
    id: page["id"].getStr,
    name: page.getTitle("Name"),
    headOfHouseholdIds: page.getRelationIds("Head(s) of Household"),
    primaryAddressId: page.getRelationIds("Primary Address"),
    memberIds: page.getRelationIds("Members"),
    createdAt: some(parseIso8601(page["created_time"].getStr)),
    lastUpdatedAt: some(parseIso8601(page["last_edited_time"].getStr)))

proc parseNPerson*(page: JsonNode): NPerson =
  result = NPerson(
    id: page["id"].getStr,
    preferredName: page.getTitle("Preferred Name"),
    firstName: page.getText("First Name"),
    middleNames: page.getText("Middle Names"),
    lastName: page.getText("Last Name"),
    birthDate: page.getDateTime("Birth Date"),
    gender: page.getSelect("Gender"),
    primaryPhoneNumber: page.getPhone("Primary Phone Number"),
    primaryEmailAddress: page.getEmail("Email Address"),
    relationshipToHff: page.getMultiSelect("Relationship to HFF"),
    addressIds: page.getRelationIds("Address"),
    marriedToId: page.getRelationIds("Married To"),
    anniversary: page.getDateTime("Anniversary"),
    parentIds: page.getRelationIds("Parents"),
    childIds: page.getRelationIds("Children"),
    createdAt: some(parseIso8601(page["created_time"].getStr)),
    lastUpdatedAt: some(parseIso8601(page["last_edited_time"].getStr)))