/* Copyright (c) 2008 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */


package sample.contacts;

import com.google.gdata.data.DateTime;
import com.google.gdata.data.PlainTextConstruct;
import com.google.gdata.data.contacts.BillingInformation;
import com.google.gdata.data.contacts.Birthday;
import com.google.gdata.data.contacts.CalendarLink;
import com.google.gdata.data.contacts.ContactEntry;
import com.google.gdata.data.contacts.ContactGroupEntry;
import com.google.gdata.data.contacts.DirectoryServer;
import com.google.gdata.data.contacts.Event;
import com.google.gdata.data.contacts.ExternalId;
import com.google.gdata.data.contacts.Gender;
import com.google.gdata.data.contacts.GroupMembershipInfo;
import com.google.gdata.data.contacts.Hobby;
import com.google.gdata.data.contacts.Initials;
import com.google.gdata.data.contacts.Jot;
import com.google.gdata.data.contacts.Language;
import com.google.gdata.data.contacts.MaidenName;
import com.google.gdata.data.contacts.Mileage;
import com.google.gdata.data.contacts.Nickname;
import com.google.gdata.data.contacts.Occupation;
import com.google.gdata.data.contacts.Priority;
import com.google.gdata.data.contacts.Relation;
import com.google.gdata.data.contacts.Sensitivity;
import com.google.gdata.data.contacts.ShortName;
import com.google.gdata.data.contacts.Subject;
import com.google.gdata.data.contacts.UserDefinedField;
import com.google.gdata.data.contacts.Website;
import com.google.gdata.data.extensions.AdditionalName;
import com.google.gdata.data.extensions.City;
import com.google.gdata.data.extensions.Country;
import com.google.gdata.data.extensions.Email;
import com.google.gdata.data.extensions.ExtendedProperty;
import com.google.gdata.data.extensions.FamilyName;
import com.google.gdata.data.extensions.FormattedAddress;
import com.google.gdata.data.extensions.FullName;
import com.google.gdata.data.extensions.GivenName;
import com.google.gdata.data.extensions.Im;
import com.google.gdata.data.extensions.Name;
import com.google.gdata.data.extensions.NamePrefix;
import com.google.gdata.data.extensions.NameSuffix;
import com.google.gdata.data.extensions.Neighborhood;
import com.google.gdata.data.extensions.OrgDepartment;
import com.google.gdata.data.extensions.OrgJobDescription;
import com.google.gdata.data.extensions.OrgName;
import com.google.gdata.data.extensions.OrgSymbol;
import com.google.gdata.data.extensions.OrgTitle;
import com.google.gdata.data.extensions.Organization;
import com.google.gdata.data.extensions.PhoneNumber;
import com.google.gdata.data.extensions.PoBox;
import com.google.gdata.data.extensions.PostCode;
import com.google.gdata.data.extensions.Region;
import com.google.gdata.data.extensions.Street;
import com.google.gdata.data.extensions.StructuredPostalAddress;
import com.google.gdata.data.extensions.When;
import com.google.gdata.data.extensions.Where;
import com.google.gdata.util.XmlBlob;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintStream;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Helper class to parse, update and display a contact.
 * It uses a bunch of anonymous inner classes for every kind of element to 
 * perform the actual job. It is defined as an enum to take advantage of the 
 * automatic instantiation and constant-specific methods.
 *
 * 
 */
public enum ElementHelper implements ElementHelperInterface {

  BILLING_INFORMATION {
    public void parse(ContactEntry contact, ElementParser parser) {
      BillingInformation billingInformation = new BillingInformation();
      billingInformation.setValue(parser.get(PropertyName.VALUE));
      contact.setBillingInformation(billingInformation);
    }

    public void print(PrintStream out, ContactEntry contact) {
       if (contact.hasBillingInformation()) {
         out.println("billing information: "
             + contact.getBillingInformation().getValue());
       }
    }

    public void update(ContactEntry dest, ContactEntry src) {
      if (src.hasBillingInformation()) {
        dest.setBillingInformation(src.getBillingInformation());
      }
    }

    public String getUsage() {
      return "<billing_information>";
    }
  },
  
  BIRTHDAY {
    public void parse(ContactEntry contact, ElementParser parser) { 
      Birthday birthday = new Birthday();
      birthday.setWhen(parser.get(PropertyName.VALUE));
      contact.setBirthday(birthday);
    }
  
    public void print(PrintStream out, ContactEntry contact) { 
      if (contact.hasBirthday()) {
        out.println("birthday: " + contact.getBirthday().getWhen());
      }
    }
    
    public void update(ContactEntry dest, ContactEntry src) {
      if (src.hasBirthday()) {
        dest.setBirthday(src.getBirthday());
      }
    }

    public String getUsage() {
      return "YYYY-MM-DD|--MM-DD";
    }
  },
  
  CALENDAR_LINK(true) {
    public void parse(ContactEntry contact, ElementParser parser) { 
      CalendarLink calendarLink = new CalendarLink();
      calendarLink.setHref(parser.get(PropertyName.VALUE));
      if (parser.has(PropertyName.REL)) {
        calendarLink.setRel(
            CalendarLink.Rel.valueOf(
                parser.get(PropertyName.REL).toUpperCase()));
      }
      if (parser.has(PropertyName.LABEL)) {
        calendarLink.setLabel(parser.get(PropertyName.LABEL));
      }
      if (parser.has(PropertyName.PRIMARY)) {
        calendarLink.setPrimary(parser.is(PropertyName.PRIMARY));
      }
      contact.addCalendarLink(calendarLink);
    }
    
    public void print(PrintStream out, ContactEntry contact) { 
      if (contact.hasCalendarLinks()) {
        out.println("calendar links:");
        for (CalendarLink calendarLink : contact.getCalendarLinks()) {
          out.print("  " + calendarLink.getHref());
          if (calendarLink.hasRel()) {
            out.print(" rel:" + calendarLink.getRel());
          } else if (calendarLink.hasLabel()) {
            out.print(" label:" + calendarLink.getLabel());
          }
          if (calendarLink.hasPrimary() && calendarLink.getPrimary()) {
            out.print(" (primary)");
          }
          out.println();
        }
      }
    }
    
    public void update(ContactEntry dest, ContactEntry src) {
      if (src.hasCalendarLinks()) {
        List<CalendarLink> calendarLinks = dest.getCalendarLinks();
        calendarLinks.clear();
        calendarLinks.addAll(src.getCalendarLinks());
      }
    }

    public String getUsage() {
      return "<href>"
          + "[,rel:<rel>]"
          + "[,label:<label>]"
          + "[,primary:true|false]";
    }
  },
  
  DIRECTORY_SERVER {
    public void parse(ContactEntry contact, ElementParser parser) { 
      DirectoryServer directoryServer = new DirectoryServer();
      directoryServer.setValue(parser.get(PropertyName.VALUE));
      contact.setDirectoryServer(directoryServer);
    }
    
    public void print(PrintStream out, ContactEntry contact) { 
      if (contact.hasDirectoryServer()) {
        out.println("directory server: " 
            + contact.getDirectoryServer().getValue());
      }
    }
    
    public void update(ContactEntry dest, ContactEntry src) {
      if (src.hasDirectoryServer()) {
        dest.setDirectoryServer(src.getDirectoryServer());
      }
    }

    public String getUsage() {
      return "<directory_server>";
    }
  },
  
  EMAIL(true) {
    public void parse(ContactEntry contact, ElementParser parser) { 
      Email email = new Email();
      email.setAddress(parser.get(PropertyName.VALUE));
      if (parser.has(PropertyName.REL)) {
        email.setRel(parser.get(PropertyName.REL));
      }
      if (parser.has(PropertyName.LABEL)) {
        email.setLabel(parser.get(PropertyName.LABEL));
      }
      if (parser.has(PropertyName.PRIMARY)) {
        email.setPrimary(parser.is(PropertyName.PRIMARY));
      }
      contact.addEmailAddress(email);
    }
    
    public void print(PrintStream out, ContactEntry contact) { 
      if (contact.hasEmailAddresses()) {
        out.println("email addresses:");
        for (Email email : contact.getEmailAddresses()) {
          out.print("  " + email.getAddress());
          if (email.getRel() != null) {
            out.print(" rel:" + email.getRel());
          }
          if (email.getLabel() != null) {
            out.print(" label:" + email.getLabel());
          }
          if (email.getPrimary()) {
            out.print(" (primary)");
          }
          out.println();
        }
      }
    }
    
    public void update(ContactEntry dest, ContactEntry src) {
      if (src.hasEmailAddresses()) {
        List<Email> emailAddresses = dest.getEmailAddresses();
        emailAddresses.clear();
        emailAddresses.addAll(src.getEmailAddresses());
      }
    }

    public String getUsage() {
      return "<email>"
          + "[,rel:<rel>]"
          + "[,label:<label>]"
          + "[,primary:true|false]";
    }
  },
  
  EVENT(true) {
    public void parse(ContactEntry contact, ElementParser parser) { 
      Event event = new Event();
      When when = new When();
      when.setStartTime(DateTime.parseDate(parser.get(PropertyName.VALUE)));
      event.setWhen(when);
      if (parser.has(PropertyName.REL)) {
        event.setRel(parser.get(PropertyName.REL));
      }
      if (parser.has(PropertyName.LABEL)) {
        event.setLabel(parser.get(PropertyName.LABEL));
      }
      contact.addEvent(event);
    }
    
    public void print(PrintStream out, ContactEntry contact) { 
      if (contact.hasEvents()) {
        out.println("events:");
        for (Event event : contact.getEvents()) {
          out.print("  " + event.getWhen().getStartTime().toString());
          if (event.hasRel()) {
            out.print(" rel:" + event.getRel());
          }
          if (event.hasLabel()) {
            out.print(" label:" + event.getLabel());
          }
          out.println();
        }
      }
    }
    
    public void update(ContactEntry dest, ContactEntry src) {
      if (src.hasEvents()) {
        List<Event> events = dest.getEvents();
        events.clear();
        events.addAll(src.getEvents());
      }
    }

    public String getUsage() {
      return "<YYYY-MM-DD>"
        + "[,rel:<rel>]"
        + "[,label:<label>]";
    }
  },
  
  EXTENDED_PROPERTY(true) {
    /**
     * Reads an XmlBlob from a file.
     * 
     * @param f the file to be readed.
     * @return the readed XmlBlog.
     * 
     * @throws IOException in case of any IO error.
     */
    private XmlBlob readFromFile(File f) throws IOException {
      StringBuffer xmlBuffer = new StringBuffer();
        BufferedReader reader = null;
      try {
        reader = new BufferedReader(new FileReader(f));
        String line;
        while ((line = reader.readLine()) != null) {
          xmlBuffer.append(line);
        }
      } finally {
        if (reader != null) {
          reader.close();
        }
      }
      XmlBlob xmlBlob = new XmlBlob();
      xmlBlob.setBlob(new String(xmlBuffer));
      return xmlBlob;
    }
    
    /**
     * Parses an ExtendedProperty.
     * 
     * @param parser the parser used for the parsing of the description. 
     * @return the parsed in ExtendedProperty.
     */
    private ExtendedProperty parse(ElementParser parser) {
      ExtendedProperty extendedProperty = new ExtendedProperty();
      extendedProperty.setName(parser.get(PropertyName.VALUE));
      if (parser.has(PropertyName.FILE)) {
        File f = new File(parser.get(PropertyName.FILE));
        if (!f.exists()) {
          throw new RuntimeException("No Such File:" + 
              parser.get(PropertyName.FILE));
        }
        try {
          extendedProperty.setXmlBlob(readFromFile(f));
        } catch (IOException ex) {
          throw new RuntimeException("Failed to read file "
              + parser.get(PropertyName.FILE));
        }
      } else if (parser.has(PropertyName.TEXT)) {
        extendedProperty.setValue(parser.get(PropertyName.TEXT));
      }
      return extendedProperty;
    }
    
    public void parse(ContactEntry contact, ElementParser parser) { 
      ExtendedProperty extendedProperty = parse(parser);
      contact.addExtendedProperty(extendedProperty);
    }

    public void parseGroup(ContactGroupEntry group, ElementParser parser) {
      ExtendedProperty extendedProperty = parse(parser);
      group.addExtendedProperty(extendedProperty);
    }
    
    public void print(PrintStream out, ContactEntry contact) { 
      if (contact.hasExtendedProperties()) {
        out.println("extended properties:");
        for (ExtendedProperty property : contact.getExtendedProperties()) {
          out.print("  " + property.getName());
          if (property.hasValue()) {
            out.print(" value:" + property.getValue());
          } else {
            out.print(" xmlBlob:" + property.getXmlBlob());
          }
          out.println();
        }
      }
    }
    
    public void update(ContactEntry dest, ContactEntry src) {
      if (src.hasExtendedProperties()) {
        List<ExtendedProperty> extendedProps = dest.getExtendedProperties();
        extendedProps.clear();
        extendedProps.addAll(src.getExtendedProperties());
      }

    }

    public String getUsage() {
      return "<name>,text:<value>|file:<XmlFilePath>";
    }
  },
  
  EXTERNAL_ID(true) {
    public void parse(ContactEntry contact, ElementParser parser) { 
      ExternalId externalId = new ExternalId();
      externalId.setValue(parser.get(PropertyName.VALUE));
      if (parser.has(PropertyName.REL)) {
        externalId.setRel(parser.get(PropertyName.REL));
      }
      if (parser.has(PropertyName.LABEL)) {
        externalId.setLabel(parser.get(PropertyName.LABEL));
      }
      contact.addExternalId(externalId);
    }
    
    public void print(PrintStream out, ContactEntry contact) { 
      if (contact.hasExternalIds()) {
        out.println("external ids:");
        for (ExternalId externalId : contact.getExternalIds()) {
          out.print("  " + externalId.getValue());
          if (externalId.hasRel()) {
            out.print(" rel:" + externalId.getRel());
          }
          if (externalId.hasLabel()) {
            out.print(" label:" + externalId.getLabel());
          }
          out.println();
        }
      }
    }
    
    public void update(ContactEntry dest, ContactEntry src) {
      if (src.hasExternalIds()) {
        List<ExternalId> externalIds = dest.getExternalIds();
        externalIds.clear();
        externalIds.addAll(src.getExternalIds());
      }
    }
    
    public String getUsage() {
      return "<external_id>,rel:<rel>|label:<label>";
    }
  },
  
  GENDER {
    public void parse(ContactEntry contact, ElementParser parser) { 
      Gender gender = new Gender();
      String value = parser.get(PropertyName.VALUE);
      if (value.equals("male")) {
        gender.setValue(Gender.Value.MALE);
      } else if (value.equals("female")) {
        gender.setValue(Gender.Value.FEMALE);
      } else {
        throw new IllegalArgumentException("gender should be male or female");
      }
      contact.setGender(gender);
    }
    
    public void print(PrintStream out, ContactEntry contact) { 
      if (contact.hasGender()) {
        out.println("gender: " 
            + contact.getGender().getValue().toString().toLowerCase());
      }
    }
    
    public void update(ContactEntry dest, ContactEntry src) {
      if (src.hasGender()) {
        dest.setGender(src.getGender());
      }
    }

    public String getUsage() {
      return "male|female";
    }
  },
  
  GROUP_MEMBERSHIP_INFO(true) {
    public void parse(ContactEntry contact, ElementParser parser) { 
      GroupMembershipInfo groupMembershipInfo = new GroupMembershipInfo();
      groupMembershipInfo.setHref(parser.get(PropertyName.VALUE));
      contact.addGroupMembershipInfo(groupMembershipInfo);
    }
    
    public void print(PrintStream out, ContactEntry contact) { 
      if (contact.hasGroupMembershipInfos()) {
        out.println("group membership info:");
        for (GroupMembershipInfo group : contact.getGroupMembershipInfos()) {
          out.print("  " + group.getHref());
          if (group.getDeleted()) {
            out.print(" (deleted)");
          }
          out.println();
        }
      }
    }
    
    public void update(ContactEntry dest, ContactEntry src) {
      if (src.hasGroupMembershipInfos()) {
        List<GroupMembershipInfo> groupMembershipInfos 
            = dest.getGroupMembershipInfos();
        groupMembershipInfos.clear();
        groupMembershipInfos.addAll(src.getGroupMembershipInfos());
      }
    }

    public String getUsage() {
      return "<url>";
    }
  },
  
  HOBBY(true) {
    public void parse(ContactEntry contact, ElementParser parser) { 
      Hobby hobby = new Hobby();
      hobby.setValue(parser.get(PropertyName.VALUE));
      contact.addHobby(hobby);
    }
    
    public void print(PrintStream out, ContactEntry contact) { 
      if (contact.hasHobbies()) {
        out.println("hobbies:");
        for (Hobby hobby : contact.getHobbies()) {
          out.println("  " + hobby.getValue());
        }
      }
    }
    
    public void update(ContactEntry dest, ContactEntry src) {
      if (src.hasHobbies()) {
        List<Hobby> hobbies = dest.getHobbies();
        hobbies.clear();
        hobbies.addAll(src.getHobbies());
      }
    }

    public String getUsage() {
      return "<hobby>";
    }
  },
  
  IM(true) {
    public void parse(ContactEntry contact, ElementParser parser) { 
      Im im = new Im();
      im.setAddress(parser.get(PropertyName.VALUE));
      if (parser.has(PropertyName.REL)) {
        im.setRel(parser.get(PropertyName.REL));
      }
      if (parser.has(PropertyName.LABEL)) {
        im.setLabel(parser.get(PropertyName.LABEL));
      }
      if (parser.has(PropertyName.PROTOCOL)) {
        im.setProtocol(parser.get(PropertyName.PROTOCOL));
      }
      if (parser.has(PropertyName.PRIMARY)) {
        im.setPrimary(parser.is(PropertyName.PRIMARY));
      }
      contact.addImAddress(im);
    }
    
    public void print(PrintStream out, ContactEntry contact) { 
      if (contact.hasImAddresses()) {
        out.println("im addresses:");
        for (Im im : contact.getImAddresses()) {
          out.print("  " + im.getAddress());
          if (im.hasRel()) {
            out.print(" rel:" + im.getRel());
          } else if (im.hasLabel()) {
            out.print(" label:" + im.getLabel());
          }
          if (im.hasProtocol()) {
            out.print(" protocol:" + im.getProtocol());
          }
          if (im.getPrimary()) {
            out.print(" (primary)");
          }
          out.println();
        }
      }
    }
    
    public void update(ContactEntry dest, ContactEntry src) {
      if (src.hasImAddresses()) {
        List<Im> ims = dest.getImAddresses();
        ims.clear();
        ims.addAll(src.getImAddresses());
      }
    }

    public String getUsage() {
      return "<im>"
          + "[,rel:<rel>]"
          + "[,label:<label>]"
          + "[,protocol:<protocol>]"
          + "[,primary:true|false]";
    }
  },

  INITIALS {
    public void parse(ContactEntry contact, ElementParser parser) { 
      Initials initials = new Initials();
      initials.setValue(parser.get(PropertyName.VALUE));
      contact.setInitials(initials);
    }
    
    public void print(PrintStream out, ContactEntry contact) { 
      if (contact.hasInitials()) {
        out.println("initials: " + contact.getInitials().getValue());
      }
    }
    
    public void update(ContactEntry dest, ContactEntry src) {
      if (src.hasInitials()) {
        dest.setInitials(src.getInitials());
      }
    }

    public String getUsage() {
      return "<initials>";
    }
  },
  
  JOT(true) {
    public void parse(ContactEntry contact, ElementParser parser) { 
      Jot jot = new Jot();
      jot.setValue(parser.get(PropertyName.VALUE));
      if (parser.has(PropertyName.REL)) {
        jot.setRel(Jot.Rel.valueOf(parser.get(PropertyName.REL).toUpperCase()));
      }
      contact.addJot(jot);
    }
    
    public void print(PrintStream out, ContactEntry contact) { 
      if (contact.hasJots()) {
        out.println("jots:");
        for (Jot jot : contact.getJots()) {
          out.print("  " + jot.getValue());
          if (jot.hasRel()) {
            out.print(" rel:" + jot.getRel().toString().toLowerCase());
          }
          out.println();
        }
      }
    }
    
    public void update(ContactEntry dest, ContactEntry src) {
      if (src.hasJots()) {
        List<Jot> jots = dest.getJots();
        jots.clear();
        jots.addAll(src.getJots());
      }
    }

    public String getUsage() {
      return "<jot>"
          + "[,rel:home|work|other|keywords|user]";
    }
  },
  
  LANGUAGE(true) {
    public void parse(ContactEntry contact, ElementParser parser) { 
      Language language = new Language();
      language.setLabel(parser.get(PropertyName.VALUE));
      contact.addLanguage(language);
    }
    
    public void print(PrintStream out, ContactEntry contact) { 
      if (contact.hasLanguages()) {
        out.println("languages:");
        for (Language language : contact.getLanguages()) {
          out.println("  " + language.getLabel());
        }
      }
    }
    
    public void update(ContactEntry dest, ContactEntry src) {
      if (src.hasLanguages()) {
        List<Language> languages = dest.getLanguages();
        languages.clear();
        languages.addAll(src.getLanguages());
      }
    }

    public String getUsage() {
      return "<language>";
    }
  },
  
  WHERE {
    public void parse(ContactEntry contact, ElementParser parser) {
      contact.setWhere(new Where(null, null, parser.get(PropertyName.VALUE)));
    }
    
    public void print(PrintStream out, ContactEntry contact) { 
      if (contact.hasWhere()) {
        out.println("where: " + contact.getWhere().getValueString());
      }
    }
    
    public void update(ContactEntry dest, ContactEntry src) {
      if (src.hasWhere()) {
        dest.setWhere(src.getWhere());
      }
    }

    public String getUsage() {
      return "<where>";
    }
  },
 
  
  MAIDEN_NAME {
    public void parse(ContactEntry contact, ElementParser parser) { 
      MaidenName maidenName = new MaidenName();
      maidenName.setValue(parser.get(PropertyName.VALUE));
      contact.setMaidenName(maidenName);
    }
    
    public void print(PrintStream out, ContactEntry contact) { 
      if (contact.hasMaidenName()) {
        out.println("maiden name: " + contact.getMaidenName().getValue());
      }
    }
    
    public void update(ContactEntry dest, ContactEntry src) {
      if (src.hasMaidenName()) {
        dest.setMaidenName(src.getMaidenName());
      }
    }

    public String getUsage() {
      return "<maiden_name>";
    }
  },
    
  MILEAGE {
    public void parse(ContactEntry contact, ElementParser parser) { 
      Mileage mileage = new Mileage();
      mileage.setValue(parser.get(PropertyName.VALUE));
      contact.setMileage(mileage);
    }
    
    public void print(PrintStream out, ContactEntry contact) { 
      if (contact.hasMileage()) {
        out.println("mileage: " + contact.getMileage().getValue());
      }
    }
    
    public void update(ContactEntry dest, ContactEntry src) {
      if (src.hasMileage()) {
        dest.setMileage(src.getMileage());
      }
    }

    public String getUsage() {
      return "<mileage>";
    }
  },
  
  NAME {
    public void parse(ContactEntry contact, ElementParser parser) { 
      Name name = new Name();
      name.setFullName(new FullName(parser.get(PropertyName.VALUE), null));
      if (parser.has(PropertyName.GIVEN)) {
        name.setGivenName(new GivenName(parser.get(PropertyName.GIVEN), null));
      } 
      if (parser.has(PropertyName.FAMILY)) {
        name.setFamilyName(
            new FamilyName(parser.get(PropertyName.FAMILY), null));
      }
      if (parser.has(PropertyName.ADDITIONAL)) {
        name.setAdditionalName(
            new AdditionalName(parser.get(PropertyName.ADDITIONAL), null));
      }
      if (parser.has(PropertyName.PREFIX)) {
        name.setNamePrefix(new NamePrefix(parser.get(PropertyName.PREFIX)));
      }
      if (parser.has(PropertyName.SUFFIX)) {
        name.setNameSuffix(new NameSuffix(parser.get(PropertyName.SUFFIX)));
      }
      contact.setName(name);
    }

    public void parseGroup(ContactGroupEntry group, ElementParser parser) {
      group.setTitle(new PlainTextConstruct(parser.get(PropertyName.VALUE)));
    }
    
    public void print(PrintStream out, ContactEntry contact) { 
      if (contact.hasName()) {
        out.println("structured name: ");
        Name name = contact.getName();
        if (name.hasFullName()) {
          out.print(" full name: " + name.getFullName().getValue());
        }
        if (name.hasGivenName()) {
          out.print(" given name: " + name.getGivenName().getValue());
        }
        if (name.hasFamilyName()) {
          out.print(" family name: " + name.getFamilyName().getValue());
        }
        if (name.hasAdditionalName()) {
          out.print(" additional name: " + name.getAdditionalName().getValue());
        }
        if (name.hasNamePrefix()) {
          out.print(" prefix: " + name.getNamePrefix().getValue());
        }
        if (name.hasNameSuffix()) {
          out.print(" suffix: " + name.getNameSuffix().getValue());
        }
        out.println();
      }
    }
    
    public void update(ContactEntry dest, ContactEntry src) {
      if (src.hasName()) {
        dest.setName(src.getName());
      }
    }

    public String getUsage() {
      return "<name>" 
          + "[,given:<givenName]"
          + "[,family:<familyName>]"
          + "[,additional:additionalName]"
          + "[,prefix:<prefix>]"
          + "[,suffix:<suffix>]";
    }
  },

  NICKNAME {
    public void parse(ContactEntry contact, ElementParser parser) { 
      Nickname nickname = new Nickname();
      nickname.setValue(parser.get(PropertyName.VALUE));
      contact.setNickname(nickname);
    }
    
    public void print(PrintStream out, ContactEntry contact) { 
      if (contact.hasNickname()) {
        out.println("nickname: " + contact.getNickname().getValue());
      }
    }
    
    public void update(ContactEntry dest, ContactEntry src) {
      if (src.hasNickname()) {
        dest.setNickname(src.getNickname());
      }
    }

    public String getUsage() {
      return "<nickname>";
    }
  },

  NOTES {
    public void parse(ContactEntry contact, ElementParser parser) { 
      contact.setContent(
          new PlainTextConstruct(parser.get(PropertyName.VALUE)));
    }
    
    public void print(PrintStream out, ContactEntry contact) { 
      if (contact.getContent() != null) { 
        out.println("notes: " 
            + contact.getTextContent().getContent().getPlainText());
      }
    }
    
    public void update(ContactEntry dest, ContactEntry src) {
      if (src.getContent() != null) {
        dest.setContent(src.getContent());
      }
    }

    public String getUsage() {
      return "<notes>";
    }
  },
  
  OCCUPATION {
    
    public void parse(ContactEntry contact, ElementParser parser) { 
      Occupation occupation = new Occupation();
      occupation.setValue(parser.get(PropertyName.VALUE));
      contact.setOccupation(occupation);
    }
    
    public void print(PrintStream out, ContactEntry contact) { 
      if (contact.hasOccupation()) {
        out.println("occupation: " + contact.getOccupation().getValue());
      }
    }
    
    public void update(ContactEntry dest, ContactEntry src) {
      if (src.hasOccupation()) {
        dest.setOccupation(src.getOccupation());
      }
    }

    public String getUsage() {
      return "<occupation>";
    }
  },

  ORGANIZATION(true) {
    public void parse(ContactEntry contact, ElementParser parser) {
      Organization org = new Organization();
      org.setOrgName(new OrgName(parser.get(PropertyName.VALUE)));
      if (parser.has(PropertyName.DEPARTMENT)) {
        org.setOrgDepartment(
            new OrgDepartment(parser.get(PropertyName.DEPARTMENT)));
      }
      if (parser.has(PropertyName.REL)) {
        org.setRel(parser.get(PropertyName.REL));
      }
      if (parser.has(PropertyName.LABEL)) {
        org.setLabel(parser.get(PropertyName.LABEL));
      }
      if (parser.has(PropertyName.TITLE)) {
        org.setOrgTitle(new OrgTitle(parser.get(PropertyName.TITLE)));
      }
      if (parser.has(PropertyName.SYMBOL)) {
        org.setOrgSymbol(new OrgSymbol(parser.get(PropertyName.SYMBOL)));
      }
      if (parser.has(PropertyName.DESCRIPTION)) {
        org.setOrgJobDescription(
            new OrgJobDescription(parser.get(PropertyName.DESCRIPTION)));
      }
      if (parser.has(PropertyName.WHERE)) {
        Where where = new Where();
        where.setValueString(parser.get(PropertyName.WHERE));
        org.setWhere(where);
      }
      contact.addOrganization(org);
    }
    
    public void print(PrintStream out, ContactEntry contact) { 
      if (contact.hasOrganizations()) {
        out.println("organizations:");
        for (Organization organization : contact.getOrganizations()) {
          out.print("  " + organization.getOrgName().getValue());
          if (organization.hasRel()) {
            out.print(" rel:" + organization.getRel());
          }
          if (organization.hasLabel()) {
            out.print(" label:" + organization.getLabel());
          }
          if (organization.hasOrgDepartment()) {
            out.print(" department:"
                + organization.getOrgDepartment().getValue());
          }
          if (organization.hasOrgTitle()) {
            out.print(" title:" + organization.getOrgTitle().getValue());
          }
          if (organization.hasOrgSymbol()) {
            out.print(" symbol:" + organization.getOrgSymbol().getValue());
          }
          if (organization.hasWhere()) {
            out.print(" where:" + organization.getWhere().getValueString());
          }
          out.println();
        }
      }
    }
    
    public void update(ContactEntry dest, ContactEntry src) {
      if (src.hasOrganizations()) {
        List<Organization> organizations = dest.getOrganizations();
        organizations.clear();
        organizations.addAll(src.getOrganizations());
      }
    }

    public String getUsage() {
      return "<name>"
          + "[,rel:<rel>]"
          + "[,label<label>]"
          + "[,primary:true|false]"
          + "[,department:<department>]"
          + "[,description:<description>]"
          + "[,symbol:<symbol>]"
          + "[,title:<title>]"
          + "[,where:<where>]";
    }
  },

  PHONE(true) {
    public void parse(ContactEntry contact, ElementParser parser) { 
      PhoneNumber phone = new PhoneNumber();
      phone.setPhoneNumber(parser.get(PropertyName.VALUE));
      if (parser.has(PropertyName.REL)) {
        phone.setRel(parser.get(PropertyName.REL));
      }
      if (parser.has(PropertyName.LABEL)) {
        phone.setLabel(parser.get(PropertyName.LABEL));
      }
      if (parser.has(PropertyName.URI)) {
        phone.setUri(parser.get(PropertyName.URI));
      }
      if (parser.has(PropertyName.PRIMARY)) {
        phone.setPrimary(parser.is(PropertyName.PRIMARY));
      }
      contact.addPhoneNumber(phone);
    }
    
    public void print(PrintStream out, ContactEntry contact) { 
      if (contact.hasPhoneNumbers()) {
        out.println("phone numbers:");
        for (PhoneNumber phone : contact.getPhoneNumbers()) {
          out.print("  " + phone.getPhoneNumber());
          if (phone.getRel() != null) {
            out.print(" rel:" + phone.getRel());
          }
          if (phone.getLabel() != null) {
            out.print(" label:" + phone.getLabel());
          }
          if (phone.getUri() != null) {
            out.print(" uri:" + phone.getUri());
          }
          if (phone.getPrimary()) {
            out.print(" (primary)");
          }
          out.println();
        }
      }
    }
    
    public void update(ContactEntry dest, ContactEntry src) {
      if (src.hasPhoneNumbers()) {
        List<PhoneNumber> phoneNumbers = dest.getPhoneNumbers();
        phoneNumbers.clear();
        phoneNumbers.addAll(src.getPhoneNumbers());
      }
    }

    public String getUsage() {
      return "<phone>"
          + "[,rel:<rel>]"
          + "[,label:<label>]"
          + "[,uri:<uri>]"
          + "[,primary:true|false]";
    }
  },
  
  PRIORITY {
    public void parse(ContactEntry contact, ElementParser parser) { 
      Priority priority = new Priority();
      priority.setRel(
          Priority.Rel.valueOf(parser.get(PropertyName.VALUE).toUpperCase()));
      contact.setPriority(priority);
    }
    
    public void print(PrintStream out, ContactEntry contact) { 
      if (contact.hasPriority()) {
        out.println("priority: " 
            + contact.getPriority().getRel().toString().toLowerCase());
      }
    }
    
    public void update(ContactEntry dest, ContactEntry src) {
      if (src.hasPriority()) {
        dest.setPriority(src.getPriority());
      }
    }

    public String getUsage() {
      return "low|normal|high";
    }
  },
  
  RELATION(true) {
    public void parse(ContactEntry contact, ElementParser parser) { 
      Relation relation = new Relation();
      relation.setValue(parser.get(PropertyName.VALUE));
      if (parser.has(PropertyName.REL)) {
        relation.setRel(
            Relation.Rel.valueOf(parser.get(PropertyName.REL).toUpperCase()));
      }
      if (parser.has(PropertyName.LABEL)) {
        relation.setLabel(parser.get(PropertyName.LABEL));
      }
      contact.addRelation(relation);
    }
    
    public void print(PrintStream out, ContactEntry contact) { 
      if (contact.hasRelations()) {
        out.println("relations:");
        for (Relation relation : contact.getRelations()) {
          out.print("  " + relation.getValue());
          if (relation.hasLabel()) {
            out.print(" label:" + relation.getLabel());
          } else if (relation.hasRel()) {
            out.print(" rel:" + relation.getRel().toString().toLowerCase());
          }
          out.println();
        }
      }
    }
    
    public void update(ContactEntry dest, ContactEntry src) {
      if (src.hasRelations()) {
        List<Relation> relations = dest.getRelations();
        relations.clear();
        relations.addAll(src.getRelations());
      }
    }

    public String getUsage() {
      return "<relation>"
          + "[,label:<label>]"
          + "[,rel:<rel>]";
    }
  },
  
  SENSITIVITY {
    
    public void parse(ContactEntry contact, ElementParser parser) { 
      Sensitivity sensitivity = new Sensitivity();
      sensitivity.setRel(
          Sensitivity.Rel.valueOf(
              parser.get(PropertyName.VALUE).toUpperCase()));
      contact.setSensitivity(sensitivity);
    }
  
    public void print(PrintStream out, ContactEntry contact) { 
      if (contact.hasSensitivity()) {
        out.println("sensitivity:" 
            + contact.getSensitivity().getRel().toString().toLowerCase());
      }
    }
    
    public void update(ContactEntry dest, ContactEntry src) {
      if (src.hasSensitivity()) {
        dest.setSensitivity(src.getSensitivity());
      }
    }

    public String getUsage() {
      return "confidental|normal|personal|private";
    }
  },
  
  SHORT_NAME {
    public void parse(ContactEntry contact, ElementParser parser) { 
      ShortName shortName = new ShortName();
      shortName.setValue(parser.get(PropertyName.VALUE));
      contact.setShortName(shortName);
    }
    
    public void print(PrintStream out, ContactEntry contact) { 
      if (contact.hasShortName()) {
        out.println("short name:" + contact.getShortName().getValue());
      }
    }
    
    public void update(ContactEntry dest, ContactEntry src) {
      if (src.hasShortName()) {
        dest.setShortName(src.getShortName());
      }
    }

    public String getUsage() {
      return "<short_name>";
    }
  },
  
  POSTAL(true) {
    public void parse(ContactEntry contact, ElementParser parser) { 
      StructuredPostalAddress address = new StructuredPostalAddress();
      if (parser.has(PropertyName.REL)) {
        address.setRel(parser.get(PropertyName.REL));
      }
      if (parser.has(PropertyName.LABEL)) {
        address.setLabel(parser.get(PropertyName.LABEL));
      }
      if (parser.has(PropertyName.PRIMARY)) {
        address.setPrimary(parser.is(PropertyName.PRIMARY));
      }
      if (parser.has(PropertyName.CITY)) {
        address.setCity(new City(parser.get(PropertyName.CITY)));
      }
      if (parser.has(PropertyName.COUNTRY)) {
        // Don't care about country code
        address.setCountry(new Country(null, parser.get(PropertyName.COUNTRY)));
      }
      if (parser.has(PropertyName.FORMATTED)) {
        address.setFormattedAddress(
            new FormattedAddress(parser.get(PropertyName.FORMATTED)));
      }
      if (parser.has(PropertyName.NEIGHBORHOOD)) {
        address.setNeighborhood(
            new Neighborhood(parser.get(PropertyName.NEIGHBORHOOD)));
      }
      if (parser.has(PropertyName.POBOX)) {
        address.setPobox(new PoBox(parser.get(PropertyName.POBOX)));
      }
      if (parser.has(PropertyName.POSTCODE)) {
        address.setPostcode(new PostCode(parser.get(PropertyName.POSTCODE)));
      }
      if (parser.has(PropertyName.REGION)) {
        address.setRegion(new Region(parser.get(PropertyName.REGION)));
      }
      if (parser.has(PropertyName.STREET)) {
        address.setStreet(new Street(parser.get(PropertyName.STREET)));
      }
      contact.addStructuredPostalAddress(address);
    }
    
    public void print(PrintStream out, ContactEntry contact) { 
      if (contact.hasStructuredPostalAddresses()) {
        out.println("addresses:");
        for (StructuredPostalAddress address 
            : contact.getStructuredPostalAddresses()) {
          out.print("  ");
          if (address.hasRel()) {
            out.print(" rel:" + address.getRel());
          }
          if (address.hasLabel()) {
            out.print(" label:" + address.getLabel());
          }
          if (address.hasCity()) {
            out.print(" city:" + address.getCity().getValue());
          }
          if (address.hasCountry()) {
            out.print(" country:" + address.getCountry().getValue());
          }
          if (address.hasFormattedAddress()) {
            out.print(" formatted:" + address.getFormattedAddress().getValue());
          }
          if (address.hasNeighborhood()) {
            out.print(" neighborhood:" + address.getNeighborhood().getValue());
          }
          if (address.hasPobox()) {
            out.print(" pobox:" + address.getPobox().getValue());
          }
          if (address.hasPostcode()) {
            out.print(" postcode:" + address.getPostcode().getValue());
          }
          if (address.hasRegion()) {
            out.print(" region:" + address.getRegion().getValue());
          }
          if (address.hasStreet()) {
            out.print(" street:" + address.getStreet().getValue());
          }
          if (address.getPrimary()) {
            out.print(" (primary)");
          }
          out.println();
        }
      }
    }
    
    public void update(ContactEntry dest, ContactEntry src) {
      if (src.hasStructuredPostalAddresses()) {
        List<StructuredPostalAddress> structuredPostalAddresses = 
            dest.getStructuredPostalAddresses();
        structuredPostalAddresses.clear();
        structuredPostalAddresses.addAll(src.getStructuredPostalAddresses());
      }
    }

    public String getUsage() {
      return "[rel:<rel>]"
          + "[,label:<label>]"
          + "[,primary:true|false]"
          + "[,city:<city>]"
          + "[,country:<country>]"
          + "[,formatted:<formattedAddress>]"
          + "[,neighborhood:<neighborhood>]"
          + "[,pobox:<poBox>]"
          + "[,postcode:<postCode>]"
          + "[,region:<region>]"
          + "[,street:<street>]";
    }
  },

  SUBJECT {
    public void parse(ContactEntry contact, ElementParser parser) { 
      Subject subject = new Subject();
      subject.setValue(parser.get(PropertyName.VALUE));
      contact.setSubject(subject);
    }
    
    public void print(PrintStream out, ContactEntry contact) { 
      if (contact.hasSubject()) {
        out.println("subject:" + contact.getSubject().getValue());
      }
    }
    
    public void update(ContactEntry dest, ContactEntry src) {
      if (src.hasSubject()) {
        dest.setSubject(src.getSubject());
      }
    }

    public String getUsage() {
      return "<subject>";
    }
  },
  
  USER_DEFINED_FIELD(true) {
    public void parse(ContactEntry contact, ElementParser parser) { 
      UserDefinedField userDefinedField = new UserDefinedField();
      userDefinedField.setValue(parser.get(PropertyName.VALUE));
      userDefinedField.setKey(parser.get(PropertyName.KEY));
      contact.addUserDefinedField(userDefinedField);
    }
    
    public void print(PrintStream out, ContactEntry contact) { 
      if (contact.hasUserDefinedFields()) {
        out.println("user defined fields:");
        for (UserDefinedField field : contact.getUserDefinedFields()) {
          out.println("  " + field.getValue() + " key: " + field.getKey());
        }
      }
    }
    
    public void update(ContactEntry dest, ContactEntry src) {
      if (src.hasUserDefinedFields()) {
        List<UserDefinedField> userDefinedFields = dest.getUserDefinedFields();
        userDefinedFields.clear();
        userDefinedFields.addAll(src.getUserDefinedFields());
      }
    }

    public String getUsage() {
      return "<value>,key:<key>";
    }
  },
  
  WEBSITE(true) {
    public void parse(ContactEntry contact, ElementParser parser) { 
      Website website = new Website();
      website.setHref(parser.get(PropertyName.VALUE));
      if (parser.has(PropertyName.REL)) {
        website.setRel(
            Website.Rel.valueOf(parser.get(PropertyName.REL).toLowerCase()));
      }
      if (parser.has(PropertyName.LABEL)) {
        website.setLabel(parser.get(PropertyName.LABEL));
      }
      if (parser.has(PropertyName.PRIMARY)) {
        website.setPrimary(parser.is(PropertyName.PRIMARY));
      }
      contact.addWebsite(website);
    }
    
    public void print(PrintStream out, ContactEntry contact) { 
      if (contact.hasWebsites()) {
        out.println("websites:");
        for (Website website : contact.getWebsites()) {
          out.print("  " + website.getHref());
          if (website.hasRel()) {
            out.print(" ref:" + website.getRel().toString().toLowerCase());
          }
          if (website.hasLabel()) {
            out.print(" label:" + website.getLabel());
          }
          if (website.getPrimary()) {
            out.print(" (primary)");
          }
          out.println();
        }
      }
    }
    
    public void update(ContactEntry dest, ContactEntry src) {
      if (src.hasWebsites()) {
        List<Website> websites = dest.getWebsites();
        websites.clear();
        websites.addAll(src.getWebsites());
      }
    }

    public String getUsage() {
      return "<url>"
          + "[,rel:<rel>]"
          + "[label:<label>]"
          + "[,primary:true|false]";
    }
  };
  
  // Flag to indicate if the element can be repeated. 
  private final boolean repetable;
  
  // some regexp for parameter parsing/checking
  private final static Pattern REPEATED_ARG_PATTERN
      = Pattern.compile("^(\\D+)\\d*$");

  // Constructors.
  private ElementHelper(boolean repetable) { this.repetable = repetable; }
  private ElementHelper() { this(false); }
  
  /**
   * The default implementation just throws an UnsuportedOperationException, and
   * only those helpers override it, what are used in parsing groups elements.
   *
   * @param group  the group the parsed element should be added or set. 
   * @param parser the parser used for the parsing of the description.
   * 
   * @throws UnsupportedOperationException in case the specific element can not 
   *         be set on a ContactGroupEntry.
   * 
   * @see ElementParser
   */
  public void parseGroup(ContactGroupEntry group, ElementParser parser) {
    throw new UnsupportedOperationException("parseGroup not supported for" 
        + this.toString().toLowerCase() + " element");
  }
  
  private static ElementHelper find(String name) 
      throws IllegalArgumentException {
    Matcher m = REPEATED_ARG_PATTERN.matcher(name);
    if (!m.matches()) {
      throw new IllegalArgumentException("badly formated parameter: " + name);
    }
    try {
      return valueOf(m.group(1).toUpperCase());
    } catch (IllegalArgumentException ex) {
      throw new IllegalArgumentException("unknown parameter: " + name);
    }
  }
  
  /**
   * Builds a contact from the list of element descriptions.
   * It delegates the element specific parsing to the appropriate helper 
   * instances. The actual element type is matched by the name of the enum 
   * instance, so the element names specified in the parameters should (almost)
   * match the name of enum instances. The exceptions are those elements what
   * can be repeated, when the parameter format is "name<n>".* Due to this 
   * formating convention we cannot use directly the valueOf() facility of the 
   * enum.
   * 
   * @param contact    the contact to build.
   * @param parameters list of element descriptions.
   * 
   */
  public static void buildContact(ContactEntry contact, 
      List<String> parameters) {
    for (String string : parameters) {
      if (!string.startsWith("--")) {
        throw new IllegalArgumentException("unknown argument: " + string);
      }
      String param = string.substring(2);
      String params[] = param.split("=", 2);
      if (params.length != 2) {
        throw new IllegalArgumentException("badly formated argument: " 
            + string);
      }
      ElementHelper helper = find(params[0]);
      if (helper == null) {
        throw new IllegalArgumentException("unknown argument: " + string);
      }
      helper.parse(contact, new ElementParser(params[1]));
    }
  }
  
  /**
   * Builds a group from the list of element descriptions.
   * It delegates the element specific parsing to the appropriate helper 
   * instances. The actual element type is matched by the name of the enum 
   * instance, so the element names specified in the parameters should (almost)
   * match the name of enum instances. The exceptions are those elements what
   * can be repeated, when the parameter format is "name<n>".* Due to this 
   * formating convention we cannot use directly the valueOf() facility of the 
   * enum.
   * 
   * @param group      the group to build.
   * @param parameters list of element descriptions.
   * 
   */
  public static void buildGroup(ContactGroupEntry group, 
      List<String> parameters) {
    for (String string : parameters) {
      if (!string.startsWith("--")) {
        throw new IllegalArgumentException("unknown argument: " + string);
      }
      String param = string.substring(2);
      String params[] = param.split("=", 2);
      if (params.length != 2) {
        throw new IllegalArgumentException("badly formated argument: " 
            + string);
      }
      ElementHelper helper = find(params[0]);
      if (helper == null) {
        throw new IllegalArgumentException("unknown argument: " + string);
      }
      helper.parseGroup(group, new ElementParser(params[1]));
    }
  }
  
  /**
   * Updates the elements of a contact entry based on the elements of another
   * contact entry.
   * Those elements are replaced in the destination contact entry what are
   * exists in the source contact. Those elements not contained by the source
   * contact are left unchanged on the destination contact.
   * 
   * @param dest the destination contact to be updated.
   * @param src  the source contact
   */
  public static void updateContact(ContactEntry dest, ContactEntry src) {
    for (ElementHelper helper : values()) {
      helper.update(dest, src);
    }
  }
  
  /**
   * Prints the content of the contact in a human readable form.
   * 
   * @param out     the stream to print to.
   * @param contact the contact to be printed out.
   */
  public static void printContact(PrintStream out, ContactEntry contact) {
    for (ElementHelper helper : values()) {
      helper.print(out, contact);
    }
  }
  
  /**
   * Gives the usage help text of all elements.
   *
   * @return the usage help text for all elements.
   */
  public static String getUsageString() {
    StringBuffer buffer = new StringBuffer();
    for (ElementHelper helper : values()) {
      buffer.append("             --" + helper.toString().toLowerCase());
      if (helper.repetable) {
        buffer.append("<n>");
      }
      buffer.append("=" + helper.getUsage() + "\n");
    }
    buffer.append(
        "Notes! <n> is a unique number for the field - several fields\n"
        + " of the same type can be present (example: im1, im2, im3).\n"
        + " Available rels and protocols can be looked up in the \n"
        + " feed documentation.\n");
    return buffer.toString();
  }
}