func (c *DeployCommand) maybeReadLocalCharm(base.APICallCloser) (deployFn, error) {
	// Charm may have been supplied via a path reference.
	ch, curl, err := charmrepo.NewCharmAtPathForceSeries(c.CharmOrBundle, c.Series, c.Force)
	// We check for several types of known error which indicate
	// that the supplied reference was indeed a path but there was
	// an issue reading the charm located there.
	if charm.IsMissingSeriesError(err) {
		return nil, err
	} else if charm.IsUnsupportedSeriesError(err) {
		return nil, errors.Errorf("%v. Use --force to deploy the charm anyway.", err)
	} else if errors.Cause(err) == zip.ErrFormat {
		return nil, errors.Errorf("invalid charm or bundle provided at %q", c.CharmOrBundle)
	} else if _, ok := err.(*charmrepo.NotFoundError); ok {
		return nil, errors.Wrap(err, errors.NotFoundf("charm or bundle at %q", c.CharmOrBundle))
	} else if err != nil && err != os.ErrNotExist {
		// If we get a "not exists" error then we attempt to interpret
		// the supplied charm reference as a URL elsewhere, otherwise
		// we return the error.
		return nil, errors.Trace(err)
	} else if err != nil {
		logger.Debugf("cannot interpret as local charm: %v", err)
		return nil, nil
	}

	return func(ctx *cmd.Context, apiRoot DeployAPI) error {
		/// AddLocalCharm
		func (c *Client) AddLocalCharm(curl *charm.URL, ch charm.Charm) (*charm.URL, error) {
			if curl.Schema != "local" {
				return nil, errors.Errorf("expected charm URL with local: schema, got %q", curl.String())
			}

			if err := c.validateCharmVersion(ch); err != nil {
				return nil, errors.Trace(err)
			}

			// Package the charm for uploading.
			var archive *os.File
			switch ch := ch.(type) {
			case *charm.CharmDir:
				var err error
				if archive, err = ioutil.TempFile("", "charm"); err != nil {
					return nil, errors.Annotate(err, "cannot create temp file")
				}
				defer os.Remove(archive.Name())
				defer archive.Close()
				if err := ch.ArchiveTo(archive); err != nil {
					return nil, errors.Annotate(err, "cannot repackage charm")
				}
				if _, err := archive.Seek(0, 0); err != nil {
					return nil, errors.Annotate(err, "cannot rewind packaged charm")
				}
			case *charm.CharmArchive:
				var err error
				if archive, err = os.Open(ch.Path); err != nil {
					return nil, errors.Annotate(err, "cannot read charm archive")
				}
				defer archive.Close()
			default:
				return nil, errors.Errorf("unknown charm type %T", ch)
			} // /AddLocalCharm

			/// UploadCharm
			func (c *Client) UploadCharm(curl *charm.URL, content io.ReadSeeker) (*charm.URL, error) {
				args := url.Values{}
				args.Add("series", curl.Series)
				args.Add("schema", curl.Schema)
				args.Add("revision", strconv.Itoa(curl.Revision))
				apiURI := url.URL{Path: "/charms", RawQuery: args.Encode()}

				contentType := "application/zip"
				var resp params.CharmsResponse
				if err := c.httpPost(content, apiURI.String(), contentType, &resp); err != nil {
					return nil, errors.Trace(err)
				}

				curl, err := charm.ParseURL(resp.CharmURL)
				if err != nil {
					return nil, errors.Annotatef(err, "bad charm URL in response")
				}
				return curl, nil
			} // /UploadCharm
			//curl, err := c.UploadCharm(curl, archive)
			if err != nil {
				return nil, errors.Trace(err)
			}
			return curl, nil
		}
		// if curl, err = apiRoot.AddLocalCharm(curl, ch); err != nil {
		// 	return errors.Trace(err)
		// }

		id := charmstore.CharmID{
			URL: curl,
			// Local charms don't need a channel.
		}

		var csMac *macaroon.Macaroon // local charms don't need one.
		ctx.Infof("Deploying charm %q.", curl.String())

		// return errors.Trace(c.deployCharm(
		// 	id,
		// 	csMac,
		// 	curl.Series,
		// 	ctx,
		// 	apiRoot,
		// ))

		/// deployCharm
		func (c *DeployCommand) deployCharm(
			id charmstore.CharmID,
			csMac *macaroon.Macaroon,
			series string,
			ctx *cmd.Context,
			apiRoot DeployAPI,
		) (rErr error) {
			charmInfo, err := apiRoot.CharmInfo(id.URL.String())
			if err != nil {
				return err
			}

			numUnits := c.NumUnits
			if charmInfo.Meta.Subordinate {
				if !constraints.IsEmpty(&c.Constraints) {
					return errors.New("cannot use --constraints with subordinate application")
				}
				if numUnits == 1 && c.PlacementSpec == "" {
					numUnits = 0
				} else {
					return errors.New("cannot use --num-units or --to with subordinate application")
				}
			}
			serviceName := c.ApplicationName
			if serviceName == "" {
				serviceName = charmInfo.Meta.Name
			}

			var configYAML []byte
			if c.Config.Path != "" {
				configYAML, err = c.Config.Read(ctx)
				if err != nil {
					return errors.Trace(err)
				}
			}

			bakeryClient, err := c.BakeryClient()
			if err != nil {
				return errors.Trace(err)
			}

			uuid, ok := apiRoot.ModelUUID()
			if !ok {
				return errors.New("API connection is controller-only (should never happen)")
			}

			deployInfo := DeploymentInfo{
				CharmID:         id,
				ApplicationName: serviceName,
				ModelUUID:       uuid,
			}

			for _, step := range c.Steps {
				err = step.RunPre(apiRoot, bakeryClient, ctx, deployInfo)
				if err != nil {
					return errors.Trace(err)
				}
			}

			defer func() {
				for _, step := range c.Steps {
					err = errors.Trace(step.RunPost(apiRoot, bakeryClient, ctx, deployInfo, rErr))
					if err != nil {
						rErr = err
					}
				}
			}()

			if id.URL != nil && id.URL.Schema != "local" && len(charmInfo.Meta.Terms) > 0 {
				ctx.Infof("Deployment under prior agreement to terms: %s",
					strings.Join(charmInfo.Meta.Terms, " "))
			}

			ids, err := handleResources(apiRoot, c.Resources, serviceName, id, csMac, charmInfo.Meta.Resources)
			if err != nil {
				return errors.Trace(err)
			}

			// return errors.Trace(apiRoot.Deploy(application.DeployArgs{
			// 	CharmID:          id,
			// 	Cons:             c.Constraints,
			// 	ApplicationName:  serviceName,
			// 	Series:           series,
			// 	NumUnits:         numUnits,
			// 	ConfigYAML:       string(configYAML),
			// 	Placement:        c.Placement,
			// 	Storage:          c.Storage,
			// 	Resources:        ids,
			// 	EndpointBindings: c.Bindings,
			// }))

			/// Deploy
			func (a *deployAPIAdapter) Deploy(args application.DeployArgs) error {
				for i, p := range args.Placement {
					if p.Scope == "model-uuid" {
						p.Scope = a.applicationClient.ModelUUID()
					}
					args.Placement[i] = p
				}

				// return errors.Trace(a.applicationClient.Deploy(args))

				/// Deploy
				func (c *Client) Deploy(args DeployArgs) error {
					deployArgs := params.ApplicationsDeploy{
						Applications: []params.ApplicationDeploy{{
							ApplicationName:  args.ApplicationName,
							Series:           args.Series,
							CharmUrl:         args.CharmID.URL.String(),
							Channel:          string(args.CharmID.Channel),
							NumUnits:         args.NumUnits,
							ConfigYAML:       args.ConfigYAML,
							Constraints:      args.Cons,
							Placement:        args.Placement,
							Storage:          args.Storage,
							EndpointBindings: args.EndpointBindings,
							Resources:        args.Resources,
						}},
					}
					var results params.ErrorResults
					var err error
					err = c.facade.FacadeCall("Deploy", deployArgs, &results)
					if err != nil {
						return err
					}
					return results.OneError()
				} // /Deploy
			} // /Deploy
			
		} // /deployCharm
		
	}, nil
}